omactiengartelle

---
name: dnd-character-generator
description: Generate cinematic D&D character portraits and tabletop RPG hero art from a text description. Ideal for Dungeons & Dragons players, dungeon masters, TTRPG campaigns, and virtual tabletop tokens — create wizards, warriors, paladins, rogues, and any fantasy character class in stunning detail via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# D&D Character Art Generator

Generate cinematic D&D character portraits and tabletop RPG hero art from a text description. Ideal for Dungeons & Dragons players, dungeon masters, TTRPG campaigns, and virtual tabletop tokens — create wizards, warriors, paladins, rogues, and any fantasy character class in stunning detail.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create dnd character art generator images.

## Quick start
```bash
node dndcharactergenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add omactiengartelle/dnd-character-generator
```

FILE:README.md
# D&D Character Art Generator

Generate cinematic D&D character portraits and tabletop RPG hero art from text descriptions. Describe your wizard, warrior, paladin, rogue, or any fantasy character class and receive a stunning, detailed portrait — perfect for Dungeons & Dragons players, dungeon masters, TTRPG campaigns, and virtual tabletop tokens.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

## Install

```bash
npx skills add omactiengartelle/dnd-character-generator
```

```bash
clawhub install dnd-character-generator
```

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage

```bash
# Default portrait — uses built-in D&D prompt
node dndcharactergenerator.js --token YOUR_TOKEN

# Describe your character
node dndcharactergenerator.js "elven ranger with a longbow, forest background, green cloak, moonlight" --token YOUR_TOKEN

# Dwarf paladin in plate armor
node dndcharactergenerator.js "dwarf paladin in gleaming plate armor, holy symbol glowing, divine light, epic fantasy" --token YOUR_TOKEN

# Tiefling warlock
node dndcharactergenerator.js "tiefling warlock with horns, purple arcane energy, dark robes, dramatic shadows" --token YOUR_TOKEN

# Landscape composition
node dndcharactergenerator.js "barbarian warrior on a cliff overlooking a battlefield" --size landscape --token YOUR_TOKEN

# Square token for virtual tabletop
node dndcharactergenerator.js "halfling rogue in leather armor, dagger, confident smirk" --size square --token YOUR_TOKEN
```

### Output

Returns a direct image URL.

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | — | **Required.** Your Neta API token |
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Image dimensions |
| `--ref` | UUID string | — | Reference image UUID for style inheritance |

### Size Dimensions

| Size | Dimensions | Best for |
|------|-----------|----------|
| `portrait` | 832 × 1216 | Character portraits, VTT tokens |
| `landscape` | 1216 × 832 | Scene illustrations, wide banners |
| `square` | 1024 × 1024 | Profile pictures, token art |
| `tall` | 704 × 1408 | Full-body character art |

## Prompt Tips

- Name the character race and class: "half-orc barbarian", "high elf wizard"
- Describe armor, weapons, and accessories in detail
- Mention lighting: "dramatic torchlight", "moonlit forest", "divine radiance"
- Add mood or setting: "battle-worn", "ancient dungeon background", "heroic pose"
- Include art style cues: "oil painting style", "highly detailed fantasy art", "cinematic"

This skill requires a Neta API token (free trial available at https://www.neta.art/open/).

FILE:dndcharactergenerator.js
#!/usr/bin/env node
import https from 'https';

const args = process.argv.slice(2);

const PROMPT = args.find(a => !a.startsWith('--')) ||
  'DnD fantasy character portrait, detailed armor and weapons, dramatic lighting, epic fantasy art style, highly detailed character design, tabletop RPG hero';

const tokenIndex = args.indexOf('--token');
const tokenFlag = tokenIndex !== -1 ? args[tokenIndex + 1] : null;

const sizeIndex = args.indexOf('--size');
const sizeArg = sizeIndex !== -1 ? args[sizeIndex + 1] : 'portrait';

const refIndex = args.indexOf('--ref');
const refArg = refIndex !== -1 ? args[refIndex + 1] : null;

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

const SIZES = {
  square: { width: 1024, height: 1024 },
  portrait: { width: 832, height: 1216 },
  landscape: { width: 1216, height: 832 },
  tall: { width: 704, height: 1408 },
};

const { width, height } = SIZES[sizeArg] || SIZES.portrait;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

function request(method, url, body) {
  return new Promise((resolve, reject) => {
    const parsed = new URL(url);
    const options = {
      hostname: parsed.hostname,
      path: parsed.pathname + parsed.search,
      method,
      headers: { ...HEADERS },
    };
    if (body) {
      const data = JSON.stringify(body);
      options.headers['content-length'] = Buffer.byteLength(data);
      const req = https.request(options, res => {
        let raw = '';
        res.on('data', c => raw += c);
        res.on('end', () => {
          try { resolve(JSON.parse(raw)); } catch { resolve(raw); }
        });
      });
      req.on('error', reject);
      req.write(data);
      req.end();
    } else {
      const req = https.request(options, res => {
        let raw = '';
        res.on('data', c => raw += c);
        res.on('end', () => {
          try { resolve(JSON.parse(raw)); } catch { resolve(raw); }
        });
      });
      req.on('error', reject);
      req.end();
    }
  });
}

function sleep(ms) {
  return new Promise(r => setTimeout(r, ms));
}

async function main() {
  const body = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: PROMPT, weight: 1 }],
    width,
    height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refArg) {
    body.inherit_params = { collection_uuid: refArg, picture_uuid: refArg };
  }

  let taskUuid;
  const makeRes = await request('POST', 'https://api.talesofai.com/v3/make_image', body);

  if (typeof makeRes === 'string') {
    taskUuid = makeRes.trim();
  } else if (makeRes && makeRes.task_uuid) {
    taskUuid = makeRes.task_uuid;
  } else {
    console.error('✗ Unexpected response from make_image:', JSON.stringify(makeRes));
    process.exit(1);
  }

  console.error(`Generating... (task: taskUuid)`);

  for (let i = 0; i < 90; i++) {
    await sleep(2000);
    const poll = await request('GET', `https://api.talesofai.com/v1/artifact/task/taskUuid`);
    const status = poll && poll.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      continue;
    }

    const url =
      (poll.artifacts && poll.artifacts[0] && poll.artifacts[0].url) ||
      poll.result_image_url;

    if (url) {
      console.log(url);
      process.exit(0);
    } else {
      console.error('✗ Task finished but no image URL found:', JSON.stringify(poll));
      process.exit(1);
    }
  }

  console.error('✗ Timed out waiting for image generation.');
  process.exit(1);
}

main().catch(err => {
  console.error('✗ Error:', err.message || err);
  process.exit(1);
});

FILE:package.json
{"name":"dnd-character-generator","version":"1.0.0","type":"module","description":"D&D Character Art Generator — AI-powered dnd character art generator","license":"MIT"}

---
name: sticker-pack-generator
description: AI sticker pack generator — create custom WhatsApp stickers, Telegram sticker packs, emoji-style art, and kawaii character stickers from any description. Generate cute chibi stickers, expressive reaction stickers, and cartoon sticker sheets instantly with AI via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Sticker Pack Generator

AI sticker pack generator — create custom WhatsApp stickers, Telegram sticker packs, emoji-style art, and kawaii character stickers from any description. Generate cute chibi stickers, expressive reaction stickers, and cartoon sticker sheets instantly with AI.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create ai sticker pack generator images.

## Quick start
```bash
node stickerpackgenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `square`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add omactiengartelle/sticker-pack-generator
```

FILE:README.md
# Sticker Pack Generator

Generate custom stickers from text descriptions using AI. Describe any character, object, or expression and instantly receive WhatsApp-ready stickers, Telegram sticker pack art, emoji-style illustrations, and kawaii chibi characters — all from a simple text prompt.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

## Install

Via npx:
```bash
npx skills add omactiengartelle/sticker-pack-generator
```

Via ClawHub:
```bash
clawhub install sticker-pack-generator
```

## Usage

```bash
node stickerpackgenerator.js "your description here" --token YOUR_TOKEN
```

### Examples

```bash
# Cute chibi cat sticker
node stickerpackgenerator.js "A cute expressive sticker of a cat, white background, bold clean outlines, chibi style, vibrant colors, sticker art, no text" --token "$NETA_TOKEN"

# Reaction sticker — surprised face
node stickerpackgenerator.js "A cute expressive sticker of a surprised anime girl, white background, bold clean outlines, chibi style, vibrant colors, sticker art, no text" --token "$NETA_TOKEN"

# Kawaii food character
node stickerpackgenerator.js "A kawaii smiling ramen bowl character, white background, bold clean outlines, chibi style, sticker art, no text" --token "$NETA_TOKEN"

# Portrait size for tall sticker formats
node stickerpackgenerator.js "A cute bunny holding a heart, white background, chibi style, sticker art" --token "$NETA_TOKEN" --size portrait

# Style inheritance from a reference image
node stickerpackgenerator.js "A sleepy panda sticker, chibi style, white background" --token "$NETA_TOKEN" --ref <picture_uuid>
```

### Output

Returns a direct image URL.

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | — | Your Neta API token (required) |
| `--size` | `square`, `portrait`, `landscape`, `tall` | `square` | Output image dimensions |
| `--ref` | UUID string | — | Reference image UUID for style inheritance |

### Size dimensions

| Size | Dimensions |
|------|------------|
| `square` | 1024 × 1024 |
| `portrait` | 832 × 1216 |
| `landscape` | 1216 × 832 |
| `tall` | 704 × 1408 |

## Token setup

A Neta API token is required. Get your free trial token at <https://www.neta.art/open/>.

Pass it with the `--token` flag:

```bash
node stickerpackgenerator.js "a cute dog sticker" --token YOUR_TOKEN
```

You can store it in a shell variable for convenience:

```bash
export NETA_TOKEN="your_token_here"
node stickerpackgenerator.js "a cute dog sticker" --token "$NETA_TOKEN"
```

This skill requires a Neta API token (free trial available at https://www.neta.art/open/).

FILE:package.json
{"name":"sticker-pack-generator","version":"1.0.0","type":"module","description":"Sticker Pack Generator — AI-powered ai sticker pack generator","license":"MIT"}

FILE:stickerpackgenerator.js
#!/usr/bin/env node
import https from 'https';

const args = process.argv.slice(2);

function getFlag(flag, hasValue = true) {
  const idx = args.indexOf(flag);
  if (idx === -1) return undefined;
  return hasValue ? args[idx + 1] : true;
}

const PROMPT = args.find(a => !a.startsWith('--') && args.indexOf(a) === args.findIndex(x => x === a) && args[args.indexOf(a) - 1] !== '--size' && args[args.indexOf(a) - 1] !== '--token' && args[args.indexOf(a) - 1] !== '--ref');
const sizeFlag = getFlag('--size') || 'square';
const tokenFlag = getFlag('--token');
const refFlag = getFlag('--ref');

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!PROMPT) {
  console.error('\n✗ Prompt required. Usage: node stickerpackgenerator.js "your prompt" --token YOUR_TOKEN');
  process.exit(1);
}

const SIZES = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const { width, height } = SIZES[sizeFlag] || SIZES.square;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

function request(method, url, body) {
  return new Promise((resolve, reject) => {
    const parsed = new URL(url);
    const options = {
      hostname: parsed.hostname,
      path: parsed.pathname + parsed.search,
      method,
      headers: HEADERS,
    };
    const req = https.request(options, res => {
      let data = '';
      res.on('data', chunk => { data += chunk; });
      res.on('end', () => {
        try { resolve(JSON.parse(data)); }
        catch { resolve(data.trim()); }
      });
    });
    req.on('error', reject);
    if (body) req.write(JSON.stringify(body));
    req.end();
  });
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function main() {
  const body = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: PROMPT, weight: 1 }],
    width,
    height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refFlag) {
    body.inherit_params = { collection_uuid: refFlag, picture_uuid: refFlag };
  }

  const makeRes = await request('POST', 'https://api.talesofai.com/v3/make_image', body);

  let taskUuid;
  if (typeof makeRes === 'string') {
    taskUuid = makeRes;
  } else if (makeRes && makeRes.task_uuid) {
    taskUuid = makeRes.task_uuid;
  } else {
    console.error('✗ Unexpected response from make_image:', JSON.stringify(makeRes));
    process.exit(1);
  }

  const MAX_ATTEMPTS = 90;
  for (let i = 0; i < MAX_ATTEMPTS; i++) {
    await sleep(2000);
    const pollRes = await request('GET', `https://api.talesofai.com/v1/artifact/task/taskUuid`);
    const status = pollRes.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      continue;
    }

    const url = (pollRes.artifacts && pollRes.artifacts[0] && pollRes.artifacts[0].url) || pollRes.result_image_url;
    if (url) {
      console.log(url);
      process.exit(0);
    } else {
      console.error('✗ Task completed but no image URL found:', JSON.stringify(pollRes));
      process.exit(1);
    }
  }

  console.error('✗ Timed out waiting for image generation.');
  process.exit(1);
}

main().catch(err => {
  console.error('✗ Error:', err.message || err);
  process.exit(1);
});

---
name: vaporwave-art-generator
description: AI vaporwave art generator — create synthwave, retrowave, and aesthetic vaporwave images with neon grids, 80s retro colors, palm trees, and lo-fi vibes. Perfect for wallpapers, album art, social media aesthetics, and retrowave content creation via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Vaporwave Art Generator

AI vaporwave art generator — create synthwave, retrowave, and aesthetic vaporwave images with neon grids, 80s retro colors, palm trees, and lo-fi vibes. Perfect for wallpapers, album art, social media aesthetics, and retrowave content creation.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create vaporwave art generator images.

## Quick start
```bash
node vaporwaveartgenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `landscape`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add omactiengartelle/vaporwave-art-generator
```

FILE:README.md
# Vaporwave Art Generator

Generate stunning vaporwave, synthwave, and retrowave images from text descriptions using AI. Describe the scene, mood, or aesthetic you want — neon grids, 80s palm tree silhouettes, chrome reflections, pastel skies, glitch effects — and receive a high-quality image URL in seconds.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

## Install

**Via npx skills:**
```bash
npx skills add omactiengartelle/vaporwave-art-generator
```

**Via ClawHub:**
```bash
clawhub install vaporwave-art-generator
```

## Usage

```bash
node vaporwaveartgenerator.js "your description here" --token YOUR_TOKEN
```

**Default prompt (no description needed):**
```bash
node vaporwaveartgenerator.js --token YOUR_TOKEN
```

**With size:**
```bash
node vaporwaveartgenerator.js "neon city skyline at dusk, pink gradients" --size portrait --token YOUR_TOKEN
```

**With reference image (style inheritance):**
```bash
node vaporwaveartgenerator.js "retro sunset over the ocean" --ref <picture_uuid> --token YOUR_TOKEN
```

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--size` | `landscape`, `portrait`, `square`, `tall` | `landscape` | Output image dimensions |
| `--token` | string | — | Your Neta API token (required) |
| `--ref` | UUID string | — | Reference image UUID for style inheritance |

### Size dimensions

| Size | Dimensions |
|------|-----------|
| `square` | 1024 × 1024 |
| `portrait` | 832 × 1216 |
| `landscape` | 1216 × 832 |
| `tall` | 704 × 1408 |

## Output

Returns a direct image URL printed to stdout. Redirect or pipe it as needed:

```bash
URL=$(node vaporwaveartgenerator.js "glowing grid, retro arcade" --token "$NETA_TOKEN")
echo "Image: $URL"
```

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Examples

```bash
# Synthwave landscape with neon grid
node vaporwaveartgenerator.js "glowing neon grid floor, retrowave sunset, pink and purple sky" --token "$NETA_TOKEN"

# Lo-fi aesthetic portrait
node vaporwaveartgenerator.js "lo-fi dreamy atmosphere, pastel colors, retro computer, cassette tapes" --size portrait --token "$NETA_TOKEN"

# Album art square
node vaporwaveartgenerator.js "chrome reflective surfaces, palm tree silhouette, 80s aesthetic, glitch effects" --size square --token "$NETA_TOKEN"

# Tall wallpaper
node vaporwaveartgenerator.js "vaporwave city, neon lights, retro arcade signs, rainy streets" --size tall --token "$NETA_TOKEN"
```

This skill requires a Neta API token (free trial available at https://www.neta.art/open/).

FILE:package.json
{"name":"vaporwave-art-generator","version":"1.0.0","type":"module","description":"Vaporwave Art Generator — AI-powered vaporwave art generator ai","license":"MIT"}

FILE:vaporwaveartgenerator.js
#!/usr/bin/env node
// Vaporwave Art Generator — AI-powered vaporwave image generation via Neta API

const args = process.argv.slice(2);

// Parse CLI arguments
let prompt = '';
let size = 'landscape';
let tokenFlag = '';
let refUuid = '';

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--token' && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === '--size' && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === '--ref' && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith('--')) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  prompt = 'synthwave vaporwave aesthetic, retro 1980s neon colors, pink and purple gradients, glowing neon grid floor, palm trees silhouette, retro computer graphics, chrome reflective surfaces, retrowave sunset, lo-fi dreamy atmosphere, glitch effects, pastel sky';
}

const SIZES = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const { width, height } = SIZES[size] ?? SIZES.landscape;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

async function makeImage() {
  const body = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: prompt, weight: 1 }],
    width,
    height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refUuid) {
    body.inherit_params = {
      collection_uuid: refUuid,
      picture_uuid: refUuid,
    };
  }

  const res = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    console.error(`✗ Failed to start image generation (res.status): text`);
    process.exit(1);
  }

  const data = await res.json();
  const taskUuid = typeof data === 'string' ? data : data.task_uuid;

  if (!taskUuid) {
    console.error('✗ No task_uuid returned:', JSON.stringify(data));
    process.exit(1);
  }

  console.error(`Generating image (task: taskUuid)...`);

  // Poll for result
  const maxAttempts = 90;
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    await new Promise(r => setTimeout(r, 2000));

    const pollRes = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: HEADERS,
    });

    if (!pollRes.ok) {
      console.error(`✗ Poll failed (pollRes.status)`);
      process.exit(1);
    }

    const result = await pollRes.json();
    const status = result.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      process.stderr.write('.');
      continue;
    }

    // Done
    process.stderr.write('\n');
    const url =
      result.artifacts?.[0]?.url ??
      result.result_image_url;

    if (!url) {
      console.error('✗ No image URL in response:', JSON.stringify(result));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error('\n✗ Timed out waiting for image generation.');
  process.exit(1);
}

makeImage().catch(err => {
  console.error('✗ Unexpected error:', err.message);
  process.exit(1);
});

---
name: anime-character-generator
description: Generate stunning full-body anime characters with custom outfits, hairstyles, and poses. Perfect for OC creation, fan art, visual novels, profile avatars, and anime-style portraits. Supports kawaii, shonen, shojo, and isekai aesthetics via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Anime Character Generator

Generate stunning full-body anime characters with custom outfits, hairstyles, and poses. Perfect for OC creation, fan art, visual novels, profile avatars, and anime-style portraits. Supports kawaii, shonen, shojo, and isekai aesthetics.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create anime character generator images.

## Quick start
```bash
node animecharactergenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add omactiengartelle/anime-character-generator
```

FILE:README.md
# Anime Character Generator

Generate stunning full-body anime characters from text descriptions. Describe the character's outfit, hairstyle, pose, color palette, and personality — and get back a high-quality anime-style illustration. Perfect for OC creation, fan art, visual novels, profile avatars, and anime-style portraits. Supports kawaii, shonen, shojo, and isekai aesthetics.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

---

## Install

**Via npx skills:**
```bash
npx skills add omactiengartelle/anime-character-generator
```

**Via ClawHub:**
```bash
clawhub install anime-character-generator
```

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage

```bash
node animecharactergenerator.js "<description>" --token YOUR_TOKEN [--size <size>] [--ref <picture_uuid>]
```

### Examples

```bash
# Default portrait — uses built-in default prompt
node animecharactergenerator.js --token "$NETA_TOKEN"

# Custom character description
node animecharactergenerator.js "silver-haired mage girl, flowing robes, glowing staff, fantasy forest background" --token "$NETA_TOKEN"

# Landscape orientation
node animecharactergenerator.js "battle-ready shonen hero, spiky hair, torn jacket, dramatic lighting" --token "$NETA_TOKEN" --size landscape

# Tall format for full-body portrait
node animecharactergenerator.js "elegant kuudere in a school uniform, long dark hair, cherry blossom background" --token "$NETA_TOKEN" --size tall

# Style reference from a previous generation
node animecharactergenerator.js "same character in winter outfit" --token "$NETA_TOKEN" --ref <picture_uuid>
```

### Output

Returns a direct image URL.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | *(required)* | Your Neta API token |
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--ref` | UUID string | *(none)* | Reference image UUID for style inheritance |

### Size dimensions

| Size | Width | Height |
|------|-------|--------|
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `square` | 1024 | 1024 |
| `tall` | 704 | 1408 |

---

## Default Prompt

If no description is provided, the skill uses:

> full body anime character, detailed outfit, expressive eyes, dynamic pose, vibrant colors, studio quality illustration


FILE:animecharactergenerator.js
#!/usr/bin/env node
// Anime Character Generator — generates anime character images via the Neta AI API

const args = process.argv.slice(2);

// Parse CLI arguments
let prompt = null;
let size = 'portrait';
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--token' && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === '--size' && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === '--ref' && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith('--') && prompt === null) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  prompt = 'full body anime character, detailed outfit, expressive eyes, dynamic pose, vibrant colors, studio quality illustration';
}

const SIZES = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const dimensions = SIZES[size] || SIZES.portrait;

const headers = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

const body = {
  storyId: 'DO_NOT_USE',
  jobType: 'universal',
  rawPrompt: [{ type: 'freetext', value: prompt, weight: 1 }],
  width: dimensions.width,
  height: dimensions.height,
  meta: { entrance: 'PICTURE,VERSE' },
  context_model_series: '8_image_edit',
};

if (refUuid) {
  body.inherit_params = {
    collection_uuid: refUuid,
    picture_uuid: refUuid,
  };
}

async function main() {
  // Submit generation job
  const submitRes = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers,
    body: JSON.stringify(body),
  });

  if (!submitRes.ok) {
    const text = await submitRes.text();
    console.error(`✗ Failed to submit job (submitRes.status): text`);
    process.exit(1);
  }

  const submitData = await submitRes.json();
  const taskUuid = typeof submitData === 'string' ? submitData : submitData.task_uuid;

  if (!taskUuid) {
    console.error('✗ No task_uuid in response:', JSON.stringify(submitData));
    process.exit(1);
  }

  // Poll for result
  const maxAttempts = 90;
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    await new Promise((resolve) => setTimeout(resolve, 2000));

    const pollRes = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers,
    });

    if (!pollRes.ok) {
      const text = await pollRes.text();
      console.error(`✗ Poll failed (pollRes.status): text`);
      process.exit(1);
    }

    const pollData = await pollRes.json();
    const status = pollData.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      // Still running, keep polling
      continue;
    }

    // Done — extract image URL
    const url =
      (pollData.artifacts && pollData.artifacts[0] && pollData.artifacts[0].url) ||
      pollData.result_image_url;

    if (!url) {
      console.error('✗ No image URL in response:', JSON.stringify(pollData));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error('✗ Timed out waiting for image generation.');
  process.exit(1);
}

main().catch((err) => {
  console.error('✗ Unexpected error:', err.message);
  process.exit(1);
});

FILE:package.json
{"name":"anime-character-generator","version":"1.0.0","type":"module","description":"Anime Character Generator — AI-powered anime character generator ai","license":"MIT"}

---
name: yearbook-photo-skill
description: Generate ai yearbook photo generator images with AI via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# AI Yearbook Photo Generator

Generate stunning ai yearbook photo generator images from a text description. Get back a direct image URL instantly.

## Token

Requires a Neta API token. Free trial available at <https://www.neta.art/open/>.

```bash
export NETA_TOKEN=your_token_here
node <script> "your prompt" --token "$NETA_TOKEN"
```

## When to use
Use when someone asks to generate or create ai yearbook photo generator images.

## Quick start
```bash
node yearbookphoto.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--style` — `anime`, `cinematic`, `realistic` (default: `realistic`)

## Install
```bash
npx skills add omactiengartelle/yearbook-photo-skill
```

FILE:README.md
# AI Yearbook Photo Generator

Generate classic ai yearbook photo generator images from a text description using AI. Powered by the Neta talesofai API, this skill returns a direct image URL in seconds — no setup beyond a token required.

---

## Install

**Via npx skills:**
```bash
npx skills add omactiengartelle/yearbook-photo-skill
```

**Via ClawHub:**
```bash
clawhub install yearbook-photo-skill
```

---

## Usage

```bash
# Default prompt (classic 1990s yearbook portrait)
node yearbookphoto.js

# Custom subject/description
node yearbookphoto.js "1990s high school yearbook portrait photo of Emma, soft studio lighting, formal attire"

# With size option
node yearbookphoto.js "senior portrait of a student" --size square

# With a reference image UUID
node yearbookphoto.js "yearbook portrait of Alex" --ref <picture_uuid>

# Pass token directly
node yearbookphoto.js "yearbook photo" --token YOUR_NETA_TOKEN
```

The script prints a single image URL to stdout on success.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--token` | string | — | Neta API token (overrides env/file) |
| `--ref` | picture_uuid | — | Reference image UUID for style inheritance |

### Size dimensions

| Size | Width | Height |
|------|-------|--------|
| `square` | 1024 | 1024 |
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `tall` | 704 | 1408 |

---

## Token setup

The script resolves your `NETA_TOKEN` in this order:

1. `--token` CLI flag
2. `NETA_TOKEN` environment variable

**Recommended:** add to your shell profile or `.env` file:
```bash
export NETA_TOKEN=your_token_here
```

```
NETA_TOKEN=your_token_here
```

---

## Default prompt

```
1990s high school yearbook portrait photo of {subject}, professional school photography studio, neutral background, soft studio lighting, formal attire, genuine smile, film grain texture, classic yearbook aesthetic
```

## Example Output

![Generated example](https://oss.talesofai.cn/picture/db2a00dc-ad39-4024-bf47-173f9f4f268e.webp)

FILE:package.json
{
  "name": "yearbook-photo-skill",
  "version": "1.6.0",
  "type": "module",
  "description": "AI Yearbook Photo Generator — AI-powered ai yearbook photo generator",
  "license": "MIT",
  "clawhub": {
    "env": [
      {
        "name": "NETA_TOKEN",
        "description": "Neta AI API token. Get it at https://www.neta.art/open/",
        "required": true
      }
    ]
  }
}

FILE:yearbookphoto.js
#!/usr/bin/env node

// --- Argument parsing ---
const args = process.argv.slice(2);
let prompt = null;
let size = "portrait";
let token = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === "--size" && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === "--token" && args[i + 1]) {
    token = args[++i];
  } else if (args[i] === "--ref" && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith("--") && prompt === null) {
    prompt = args[i];
  }
}

if (!prompt) {
  prompt =
    "1990s high school yearbook portrait photo of a student, professional school photography studio, neutral background, soft studio lighting, formal attire, genuine smile, film grain texture, classic yearbook aesthetic";
}

// --- Token resolution ---
if (!token) {
  console.error(
    '\n✗ Token required. Pass via: --token YOUR_TOKEN'
  );
  process.exit(1);
}

// --- Size map ---
const sizeMap = {
  square: { width: 1024, height: 1024 },
  portrait: { width: 832, height: 1216 },
  landscape: { width: 1216, height: 832 },
  tall: { width: 704, height: 1408 },
};

const { width, height } = sizeMap[size] || sizeMap.portrait;

// --- Headers ---
const headers = {
  "x-token": token,
  "x-platform": "nieta-app/web",
  "content-type": "application/json",
};

// --- Build request body ---
const body = {
  storyId: "DO_NOT_USE",
  jobType: "universal",
  rawPrompt: [{ type: "freetext", value: prompt, weight: 1 }],
  width,
  height,
  meta: { entrance: "PICTURE,VERSE" },
  context_model_series: "8_image_edit",
};

if (refUuid) {
  body.inherit_params = {
    collection_uuid: refUuid,
    picture_uuid: refUuid,
  };
}

// --- Submit job ---
async function main() {
  let taskUuid;

  const makeRes = await fetch("https://api.talesofai.cn/v3/make_image", {
    method: "POST",
    headers,
    body: JSON.stringify(body),
  });

  if (!makeRes.ok) {
    const text = await makeRes.text();
    console.error(`Error submitting job (makeRes.status): text`);
    process.exit(1);
  }

  const makeData = await makeRes.json();

  if (typeof makeData === "string") {
    taskUuid = makeData;
  } else if (makeData && makeData.task_uuid) {
    taskUuid = makeData.task_uuid;
  } else {
    console.error("Unexpected response from make_image:", JSON.stringify(makeData));
    process.exit(1);
  }

  // --- Poll for result ---
  const maxAttempts = 90;
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    await new Promise((r) => setTimeout(r, 2000));

    const pollRes = await fetch(
      `https://api.talesofai.cn/v1/artifact/task/taskUuid`,
      { headers }
    );

    if (!pollRes.ok) {
      const text = await pollRes.text();
      console.error(`Error polling task (pollRes.status): text`);
      process.exit(1);
    }

    const pollData = await pollRes.json();
    const status = pollData.task_status;

    if (status === "PENDING" || status === "MODERATION") {
      continue;
    }

    // Done
    const url =
      (pollData.artifacts && pollData.artifacts[0] && pollData.artifacts[0].url) ||
      pollData.result_image_url;

    if (!url) {
      console.error("No image URL in response:", JSON.stringify(pollData));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error("Timed out waiting for image generation.");
  process.exit(1);
}

main().catch((err) => {
  console.error("Fatal error:", err.message || err);
  process.exit(1);
});

---
name: furry-art-skill
description: Generate furry art generator ai images with AI via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Furry Art Generator

Generate stunning furry art generator ai images from a text description. Get back a direct image URL instantly.

## Token

Requires a Neta API token. Free trial available at <https://www.neta.art/open/>.

```bash
export NETA_TOKEN=your_token_here
node <script> "your prompt" --token "$NETA_TOKEN"
```

## When to use
Use when someone asks to generate or create furry art generator images.

## Quick start
```bash
node furryart.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `square`)
- `--style` — `anime`, `cinematic`, `realistic` (default: `anime`)

## Install
```bash
npx skills add omactiengartelle/furry-art-skill
```

FILE:README.md
# Furry Art Generator

> Powered by the **Neta AI image generation API** (`api.talesofai.com`) — the same service as [neta.art](https://www.neta.art/open/).

Generate stunning **furry art generator ai** images from a text prompt — powered by the Neta talesofai API. Get back a direct image URL in seconds.

---

## Install

```bash
# Via npx skills
npx skills add omactiengartelle/furry-art-skill

# Via ClawHub
clawhub install furry-art-skill
```

---

## Usage

```bash
# Basic — uses built-in default prompt
node furryart.js

# Custom prompt
node furryart.js "red fox warrior in armor, fantasy setting, detailed fur"

# Specify size
node furryart.js "wolf mage casting spells" --size portrait

# Reference an existing image for style inheritance
node furryart.js "same character, different pose" --ref <picture_uuid>
```

The script prints the final image URL to stdout and progress info to stderr.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--size` | `square`, `portrait`, `landscape`, `tall` | `square` | Output image dimensions |
| `--token` | string | — | Override the API token for this run |
| `--ref` | picture_uuid | — | Inherit style/params from an existing image |

### Size dimensions

| Name | Width | Height |
|------|-------|--------|
| `square` | 1024 | 1024 |
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `tall` | 704 | 1408 |

---

## Token setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Default prompt

When no prompt is provided, the skill uses:

> anthropomorphic animal character, furry art style, detailed fur texture, expressive eyes, vibrant colors, clean linework, digital illustration

---

## Example output

```
Submitting: "red fox knight in enchanted forest" [square 1024×1024]
Task: abc123-def456-...
Waiting… attempt 3/90 [PENDING]
https://cdn.talesofai.cn/artifacts/abc123.png
```

## Example Output

![Generated example](https://oss.talesofai.cn/picture/7312ff44-8e15-4c55-b3dd-f6c1b248834e.webp)

---

This skill requires a Neta API token (free trial available at https://www.neta.art/open/).

FILE:furryart.js
#!/usr/bin/env node

// --- Argument parsing ---
const args = process.argv.slice(2);
let prompt = null;
let size = "square";
let token = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === "--size" && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === "--token" && args[i + 1]) {
    token = args[++i];
  } else if (args[i] === "--ref" && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith("--") && prompt === null) {
    prompt = args[i];
  }
}

if (!prompt) {
  prompt =
    "anthropomorphic animal character, furry art style, detailed fur texture, expressive eyes, vibrant colors, clean linework, digital illustration";
}

// --- Token resolution ---
if (!token) {
  console.error(
    '\n✗ Token required. Pass via: --token YOUR_TOKEN'
  );
  process.exit(1);
}

// --- Size map ---
const SIZES = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const { width, height } = SIZES[size] ?? SIZES.square;

// --- Headers ---
const HEADERS = {
  "x-token": token,
  "x-platform": "nieta-app/web",
  "content-type": "application/json",
};

// --- Build request body ---
const body = {
  storyId: "DO_NOT_USE",
  jobType: "universal",
  rawPrompt: [{ type: "freetext", value: prompt, weight: 1 }],
  width,
  height,
  meta: { entrance: "PICTURE,VERSE" },
  context_model_series: "8_image_edit",
};

if (refUuid) {
  body.inherit_params = {
    collection_uuid: refUuid,
    picture_uuid: refUuid,
  };
}

// --- Submit job ---
async function submitJob() {
  const res = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    throw new Error(`Submit failed (res.status): text`);
  }

  const data = await res.json();

  // Response may be a plain string or an object with task_uuid
  if (typeof data === "string") return data;
  if (data.task_uuid) return data.task_uuid;
  throw new Error(`Unexpected response: JSON.stringify(data)`);
}

// --- Poll for result ---
async function pollTask(taskUuid) {
  const url = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  const MAX_ATTEMPTS = 90;
  const INTERVAL_MS = 2000;

  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
    await new Promise((r) => setTimeout(r, INTERVAL_MS));

    const res = await fetch(url, { headers: HEADERS });
    if (!res.ok) {
      const text = await res.text();
      throw new Error(`Poll failed (res.status): text`);
    }

    const data = await res.json();
    const status = data.task_status;

    if (status === "PENDING" || status === "MODERATION") {
      process.stderr.write(`\rWaiting… attempt attempt/MAX_ATTEMPTS [status]`);
      continue;
    }

    // Done — extract image URL
    process.stderr.write("\n");
    const imageUrl =
      data.artifacts?.[0]?.url ?? data.result_image_url ?? null;

    if (!imageUrl) {
      throw new Error(`No image URL in response: JSON.stringify(data)`);
    }

    return imageUrl;
  }

  throw new Error("Timed out waiting for image generation.");
}

// --- Main ---
(async () => {
  try {
    process.stderr.write(`Submitting: "prompt" [size width×height]\n`);
    const taskUuid = await submitJob();
    process.stderr.write(`Task: taskUuid\n`);
    const imageUrl = await pollTask(taskUuid);
    console.log(imageUrl);
  } catch (err) {
    console.error(`Error: err.message`);
    process.exit(1);
  }
})();

FILE:package.json
{
  "name": "furry-art-skill",
  "version": "1.6.4",
  "type": "module",
  "description": "Furry Art Generator \u2014 AI-powered furry art generator ai",
  "license": "MIT",
  "clawhub": {
    "env": [
      {
        "name": "NETA_TOKEN",
        "description": "Neta AI API token. Get it at https://www.neta.art/open/",
        "required": true
      }
    ]
  }
}

---
name: album-cover-skill
description: Generate ai album cover generator images with AI via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# AI Album Cover Generator

Generate stunning ai album cover generator images from a text description. Get back a direct image URL instantly.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create ai album cover generator images.

## Quick start
```bash
node albumcover.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `square`)
- `--style` — `anime`, `cinematic`, `realistic` (default: `cinematic`)

## Install
```bash
npx skills add omactiengartelle/album-cover-skill
```

FILE:README.md
# AI Album Cover Generator

> Powered by the **Neta AI image generation API** (`api.talesofai.com`) — the same service as [neta.art](https://www.neta.art/open/).

Generate stunning album cover art from a text description using AI. Powered by the Neta talesofai API — get back a direct image URL in seconds.

---

## Install

**Via npx skills:**
```bash
npx skills add omactiengartelle/album-cover-skill
```

**Via ClawHub:**
```bash
clawhub install album-cover-skill
```

---

## Usage

```bash
# Basic — uses the built-in default prompt
node albumcover.js

# Custom prompt
node albumcover.js "dark synthwave aesthetic, neon purple cityscape, retro 80s vibes"

# Square cover (default)
node albumcover.js "jazz trio, warm tones, vintage vinyl feel" --size square

# Portrait format
node albumcover.js "epic orchestral album, stormy sky, dramatic" --size portrait

# With a reference image UUID
node albumcover.js "same style but winter theme" --ref abc123-uuid-here

# Pass token explicitly
node albumcover.js "lo-fi beats cover art" --token YOUR_TOKEN_HERE
```

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--size` | `square`, `portrait`, `landscape`, `tall` | `square` | Output image dimensions |
| `--style` | `anime`, `cinematic`, `realistic` | `cinematic` | Visual style (informational) |
| `--ref` | `<picture_uuid>` | — | Reference image UUID for style inheritance |
| `--token` | `<token>` | — | Neta API token (required) |

### Size dimensions

| Size | Width | Height |
|------|-------|--------|
| `square` | 1024 | 1024 |
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `tall` | 704 | 1408 |

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Output

The script prints a single direct image URL to stdout on success, making it easy to pipe into other tools:

```bash
node albumcover.js "cyberpunk album cover, rain, neon" | pbcopy   # copy URL
node albumcover.js "jazz" | xargs curl -o cover.jpg               # download
```

---

## Default Prompt

When no prompt is provided, the script uses:

> professional album cover art, dramatic lighting, bold composition, music album aesthetic, high contrast, visually striking, suitable for streaming platforms

## Example Output

![Generated example](https://oss.talesofai.cn/picture/3ad8410d-cfab-4c14-91dd-70b52fae9ba6.webp)

---

This skill requires a Neta API token (free trial available at https://www.neta.art/open/).

FILE:albumcover.js
#!/usr/bin/env node

// --- Argument parsing ---
const args = process.argv.slice(2);
let prompt = null;
let size = "square";
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === "--size" && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === "--token" && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === "--ref" && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith("--") && prompt === null) {
    prompt = args[i];
  }
}

if (!prompt) {
  prompt =
    "professional album cover art, dramatic lighting, bold composition, music album aesthetic, high contrast, visually striking, suitable for streaming platforms";
}

// --- Token resolution ---
const TOKEN = tokenFlag || process.env.NETA_TOKEN;

if (!TOKEN) {
  console.error(
    '\n✗ Token required. Pass via: --token YOUR_TOKEN'
  );
  process.exit(1);
}

// --- Size mapping ---
const SIZES = {
  square: { width: 1024, height: 1024 },
  portrait: { width: 832, height: 1216 },
  landscape: { width: 1216, height: 832 },
  tall: { width: 704, height: 1408 },
};

const { width, height } = SIZES[size] || SIZES.square;

// --- Headers ---
const HEADERS = {
  "x-token": TOKEN,
  "x-platform": "nieta-app/web",
  "content-type": "application/json",
};

// --- Build request body ---
const body = {
  storyId: "DO_NOT_USE",
  jobType: "universal",
  rawPrompt: [{ type: "freetext", value: prompt, weight: 1 }],
  width,
  height,
  meta: { entrance: "PICTURE,VERSE" },
  context_model_series: "8_image_edit",
};

if (refUuid) {
  body.inherit_params = {
    collection_uuid: refUuid,
    picture_uuid: refUuid,
  };
}

// --- Submit job ---
async function makeImage() {
  const res = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    throw new Error(`make_image failed (res.status): text`);
  }

  const data = await res.json();
  const taskUuid =
    typeof data === "string" ? data : data.task_uuid;

  if (!taskUuid) {
    throw new Error(`No task_uuid in response: JSON.stringify(data)`);
  }

  return taskUuid;
}

// --- Poll for result ---
async function pollTask(taskUuid) {
  const url = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  const MAX_ATTEMPTS = 90;
  const INTERVAL_MS = 2000;

  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
    await new Promise((r) => setTimeout(r, INTERVAL_MS));

    const res = await fetch(url, { headers: HEADERS });

    if (!res.ok) {
      const text = await res.text();
      throw new Error(`poll failed (res.status): text`);
    }

    const data = await res.json();
    const status = data.task_status;

    if (status === "PENDING" || status === "MODERATION") {
      continue;
    }

    // Done — extract image URL
    const imageUrl =
      (data.artifacts && data.artifacts[0] && data.artifacts[0].url) ||
      data.result_image_url;

    if (!imageUrl) {
      throw new Error(`No image URL in response: JSON.stringify(data)`);
    }

    return imageUrl;
  }

  throw new Error(`Timed out waiting for task taskUuid after MAX_ATTEMPTS attempts`);
}

// --- Main ---
(async () => {
  try {
    const taskUuid = await makeImage();
    const imageUrl = await pollTask(taskUuid);
    console.log(imageUrl);
    process.exit(0);
  } catch (err) {
    console.error("Error:", err.message);
    process.exit(1);
  }
})();

FILE:package.json
{
  "name": "album-cover-skill",
  "version": "1.5.7",
  "type": "module",
  "description": "AI Album Cover Generator \u2014 AI-powered ai album cover generator",
  "license": "MIT",
  "clawhub": {
    "env": [
      {
        "name": "NETA_TOKEN",
        "description": "Neta AI API token. Get it at https://www.neta.art/open/",
        "required": true
      }
    ]
  }
}