@1aboveio/skills 1.0.8 → 1.0.9

package/skills/content/image-gen/scripts/credentials.test.mjs

@@ -1,212 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtemp, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, it } from 'node:test';
-
-import {
-  DEFAULT_OPENAI_BASE_URL,
-  expandPiValue,
-  piModelsPath,
-  resolveGemini,
-  resolveOpenAI,
-} from './credentials.mjs';
-
-async function writeConfig(contents) {
-  const dir = await mkdtemp(join(tmpdir(), 'image-gen-creds-'));
-  const path = join(dir, 'models.json');
-  await writeFile(path, typeof contents === 'string' ? contents : JSON.stringify(contents));
-  return path;
-}
-
-const piConfig = (openai) => ({ providers: { openai } });
-
-// A literal key, the case where the pi fallback can actually produce one.
-const LITERAL = { baseUrl: 'https://pi-gateway.example/v1', apiKey: 'pi-key' };
-
-describe('expandPiValue', () => {
-  it('passes literals through', () => {
-    assert.equal(expandPiValue('sk-literal', {}).value, 'sk-literal');
-  });
-
-  it('expands $VAR and ${VAR}', () => {
-    assert.equal(expandPiValue('$KEY', { KEY: 'v' }).value, 'v');
-    assert.equal(expandPiValue('${KEY}', { KEY: 'v' }).value, 'v');
-  });
-
-  it('expands variables embedded in surrounding text', () => {
-    const resolved = expandPiValue('https://$HOST/v1', { HOST: 'gw.example' });
-
-    assert.equal(resolved.value, 'https://gw.example/v1');
-  });
-
-  it('reports every unresolved variable instead of expanding partially', () => {
-    const resolved = expandPiValue('$A-$B', { A: 'a' });
-
-    assert.equal(resolved.value, undefined);
-    assert.deepEqual(resolved.missing, ['B']);
-  });
-
-  it('treats an empty variable as unset, as pi does', () => {
-    assert.deepEqual(expandPiValue('$KEY', { KEY: '' }).missing, ['KEY']);
-  });
-
-  it('honors the $$ and $! escapes', () => {
-    assert.equal(expandPiValue('$$KEY', { KEY: 'v' }).value, '$KEY');
-    assert.equal(expandPiValue('$!cmd', {}).value, '!cmd');
-  });
-
-  it('keeps a dangling $ or unterminated ${ literal', () => {
-    assert.equal(expandPiValue('pre$', {}).value, 'pre$');
-    assert.equal(expandPiValue('${unterminated', {}).value, '${unterminated');
-    assert.equal(expandPiValue('$ {KEY}', {}).value, '$ {KEY}');
-  });
-
-  it('flags !command values rather than executing them', () => {
-    const resolved = expandPiValue('!security find-generic-password -w', {});
-
-    assert.equal(resolved.value, undefined);
-    assert.equal(resolved.command, 'security find-generic-password -w');
-  });
-});
-
-describe('resolveOpenAI', () => {
-  it('prefers the environment over the pi config', async () => {
-    const configPath = await writeConfig(piConfig(LITERAL));
-    const resolved = await resolveOpenAI({
-      env: { OPENAI_API_KEY: 'env-key', OPENAI_BASE_URL: 'https://env-gateway.example/v1' },
-      configPath,
-    });
-
-    assert.equal(resolved.ok, true);
-    assert.equal(resolved.apiKey, 'env-key');
-    assert.equal(resolved.baseUrl, 'https://env-gateway.example/v1');
-  });
-
-  it('defaults the base URL when only the env key is set', async () => {
-    const resolved = await resolveOpenAI({ env: { OPENAI_API_KEY: 'k' }, configPath: '/nope' });
-
-    assert.equal(resolved.baseUrl, DEFAULT_OPENAI_BASE_URL);
-  });
-
-  it('strips trailing slashes so the path join stays well formed', async () => {
-    const resolved = await resolveOpenAI({
-      env: { OPENAI_API_KEY: 'k', OPENAI_BASE_URL: 'https://gw.example/v1///' },
-      configPath: '/nope',
-    });
-
-    assert.equal(resolved.baseUrl, 'https://gw.example/v1');
-  });
-
-  it('falls back to a literal pi key, taking pi\'s base URL with it', async () => {
-    const configPath = await writeConfig(piConfig(LITERAL));
-    const resolved = await resolveOpenAI({ env: {}, configPath });
-
-    assert.equal(resolved.ok, true);
-    assert.equal(resolved.apiKey, 'pi-key');
-    assert.equal(resolved.baseUrl, 'https://pi-gateway.example/v1');
-    assert.match(resolved.source, /^pi config/);
-  });
-
-  it('expands a pi key that references another variable', async () => {
-    const configPath = await writeConfig(piConfig({ ...LITERAL, apiKey: '$GAPSEE_KEY' }));
-    const resolved = await resolveOpenAI({ env: { GAPSEE_KEY: 'sk-real' }, configPath });
-
-    assert.equal(resolved.ok, true);
-    assert.equal(resolved.apiKey, 'sk-real');
-  });
-
-  it('never sends an unexpanded template as the bearer token', async () => {
-    // The bug this guards: `$OPENAI_API_KEY` reaching the API verbatim.
-    const configPath = await writeConfig(piConfig({ ...LITERAL, apiKey: '$SOME_KEY' }));
-    const resolved = await resolveOpenAI({ env: {}, configPath });
-
-    assert.equal(resolved.ok, false);
-    assert.match(resolved.reason, /\$SOME_KEY/);
-  });
-
-  it('explains why a pi entry pointing at $OPENAI_API_KEY can never satisfy the fallback', async () => {
-    const configPath = await writeConfig(piConfig({ ...LITERAL, apiKey: '$OPENAI_API_KEY' }));
-    const resolved = await resolveOpenAI({ env: {}, configPath });
-
-    assert.equal(resolved.ok, false);
-    assert.match(resolved.reason, /can never satisfy this fallback/);
-  });
-
-  it('expands a templated pi base URL', async () => {
-    const configPath = await writeConfig(piConfig({ apiKey: 'pi-key', baseUrl: 'https://$GW/v1' }));
-    const resolved = await resolveOpenAI({ env: { GW: 'gw.example' }, configPath });
-
-    assert.equal(resolved.baseUrl, 'https://gw.example/v1');
-  });
-
-  it('fails rather than silently retargeting when the pi base URL cannot expand', async () => {
-    // Falling back to api.openai.com here would send a gateway key to OpenAI.
-    const configPath = await writeConfig(piConfig({ apiKey: 'pi-key', baseUrl: 'https://$GW/v1' }));
-    const resolved = await resolveOpenAI({ env: {}, configPath });
-
-    assert.equal(resolved.ok, false);
-    assert.match(resolved.reason, /\$GW/);
-  });
-
-  it('defaults the base URL when the pi provider omits one', async () => {
-    const configPath = await writeConfig(piConfig({ apiKey: 'pi-key' }));
-    const resolved = await resolveOpenAI({ env: {}, configPath });
-
-    assert.equal(resolved.baseUrl, DEFAULT_OPENAI_BASE_URL);
-  });
-
-  it('reports !command keys as unsupported instead of running them', async () => {
-    const configPath = await writeConfig(piConfig({ ...LITERAL, apiKey: '!echo sk-x' }));
-    const resolved = await resolveOpenAI({ env: {}, configPath });
-
-    assert.equal(resolved.ok, false);
-    assert.match(resolved.reason, /does not execute config commands/);
-  });
-
-  it('ignores OPENAI_BASE_URL when the key comes from pi', async () => {
-    const configPath = await writeConfig(piConfig(LITERAL));
-    const resolved = await resolveOpenAI({
-      env: { OPENAI_BASE_URL: 'https://env-gateway.example/v1' },
-      configPath,
-    });
-
-    assert.equal(resolved.baseUrl, 'https://pi-gateway.example/v1');
-  });
-
-  it('fails with the config path when there is nothing to fall back to', async () => {
-    const missing = await resolveOpenAI({ env: {}, configPath: '/definitely/not/here.json' });
-    const malformed = await resolveOpenAI({ env: {}, configPath: await writeConfig('{ not json') });
-    const noKey = await writeConfig(piConfig({ baseUrl: 'https://x.example/v1' }));
-    const otherProvider = await writeConfig({ providers: { deepseek: { apiKey: 'k' } } });
-
-    assert.equal(missing.ok, false);
-    assert.match(missing.reason, /definitely\/not\/here\.json/);
-    assert.equal(malformed.ok, false);
-    assert.equal((await resolveOpenAI({ env: {}, configPath: noKey })).ok, false);
-    assert.equal((await resolveOpenAI({ env: {}, configPath: otherProvider })).ok, false);
-  });
-});
-
-describe('piModelsPath', () => {
-  it('honors PI_CODING_AGENT_DIR', () => {
-    assert.equal(piModelsPath({ PI_CODING_AGENT_DIR: '/custom/agent' }), '/custom/agent/models.json');
-  });
-
-  it('defaults to the pi agent directory under $HOME', () => {
-    assert.match(piModelsPath({}), /[/\\]\.pi[/\\]agent[/\\]models\.json$/);
-  });
-});
-
-describe('resolveGemini', () => {
-  it('reads the env key', () => {
-    assert.equal(resolveGemini({ env: { GEMINI_API_KEY: 'g-key' } }).apiKey, 'g-key');
-  });
-
-  it('fails with a reason without one', () => {
-    const resolved = resolveGemini({ env: {} });
-
-    assert.equal(resolved.ok, false);
-    assert.match(resolved.reason, /GEMINI_API_KEY/);
-  });
-});

package/skills/content/image-gen/scripts/options.test.mjs

@@ -1,245 +0,0 @@
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-
-import {
-  GEMINI_ASPECT_RATIOS,
-  describeSizeMismatch,
-  extensionForMimeType,
-  imageDimensions,
-  geminiAspectRatio,
-  openAiSize,
-  parseArgs,
-  resolveOutputPath,
-} from './options.mjs';
-
-describe('parseArgs', () => {
-  it('joins the positional words into the prompt', () => {
-    const { prompt, errors } = parseArgs(['a', 'red', 'fox']);
-
-    assert.equal(prompt, 'a red fox');
-    assert.deepEqual(errors, []);
-  });
-
-  it('accepts --flag value and --flag=value alike', () => {
-    assert.equal(parseArgs(['p', '--model', 'm']).flags.model, 'm');
-    assert.equal(parseArgs(['p', '--model=m']).flags.model, 'm');
-  });
-
-  it('rejects an unknown flag instead of ignoring it', () => {
-    // The old parser accepted --qualtiy silently and generated at the default.
-    const { errors } = parseArgs(['p', '--qualtiy', 'high']);
-
-    assert.equal(errors.length, 1);
-    assert.match(errors[0], /Unknown option --qualtiy/);
-  });
-
-  it('suggests the intended flag for a near miss', () => {
-    assert.match(parseArgs(['p', '--outpt', 'x.png']).errors[0], /Did you mean --output\?/);
-  });
-
-  it('does not let a flag swallow the next flag as its value', () => {
-    // `--quality --output x.png` used to set quality="--output" and lose the path.
-    const { flags, errors } = parseArgs(['p', '--quality', '--output', 'x.png']);
-
-    assert.match(errors[0], /--quality needs a value/);
-    assert.equal(flags.output, 'x.png');
-  });
-
-  it('reports a trailing flag with no value', () => {
-    assert.match(parseArgs(['p', '--output']).errors[0], /--output needs a value/);
-  });
-
-  it('validates enumerated flag values', () => {
-    assert.match(parseArgs(['p', '--provider', 'midjourney']).errors[0], /Invalid --provider/);
-    assert.match(parseArgs(['p', '--quality', 'ultra']).errors[0], /Invalid --quality/);
-  });
-
-  it('warns and drops a flag that does not apply to the chosen provider', () => {
-    const { flags, warnings } = parseArgs(['p', '--provider', 'gemini', '--quality', 'high']);
-
-    assert.equal(flags.quality, undefined);
-    assert.match(warnings[0], /--quality applies to openai only/);
-  });
-
-  it('keeps provider-specific flags when the provider does match', () => {
-    assert.equal(parseArgs(['p', '--quality', 'high']).flags.quality, 'high');
-  });
-});
-
-describe('openAiSize', () => {
-  it('defaults to a square', () => {
-    assert.equal(openAiSize(undefined).value, '1024x1024');
-  });
-
-  it('accepts the documented sizes and rejects others', () => {
-    assert.equal(openAiSize('1536x1024').value, '1536x1024');
-    assert.match(openAiSize('800x600').error, /Invalid size/);
-  });
-});
-
-describe('geminiAspectRatio', () => {
-  it('sends nothing when no size is given', () => {
-    assert.equal(geminiAspectRatio(undefined).value, undefined);
-    assert.equal(geminiAspectRatio('auto').value, undefined);
-  });
-
-  it('passes a supported ratio straight through', () => {
-    assert.equal(geminiAspectRatio('16:9').value, '16:9');
-  });
-
-  it('snaps pixel dimensions to the nearest supported ratio', () => {
-    // This is the whole point: --size used to be discarded for Gemini.
-    assert.equal(geminiAspectRatio('1536x1024').value, '3:2');
-    assert.equal(geminiAspectRatio('1024x1536').value, '2:3');
-    assert.equal(geminiAspectRatio('1920x1080').value, '16:9');
-    assert.equal(geminiAspectRatio('1024x1024').value, '1:1');
-  });
-
-  it('reports what it snapped away from, so the change is visible', () => {
-    const snapped = geminiAspectRatio('1000x500');
-
-    // 2:1 is not supported; 16:9 is the closest thing to it that is.
-    assert.equal(snapped.value, '16:9');
-    assert.equal(snapped.snappedFrom, '1000x500');
-  });
-
-  it('treats an exact square as exact, not snapped', () => {
-    assert.equal(geminiAspectRatio('1024x1024').snappedFrom, undefined);
-  });
-
-  it('rejects a well-formed ratio the API does not support', () => {
-    const rejected = geminiAspectRatio('7:5');
-
-    assert.match(rejected.error, /does not support the aspect ratio "7:5"/);
-    assert.match(rejected.error, /16:9/);
-  });
-
-  it('rejects unparseable sizes and zero dimensions', () => {
-    assert.match(geminiAspectRatio('huge').error, /Invalid size/);
-    assert.match(geminiAspectRatio('0x100').error, /zero dimension/);
-  });
-
-  it('only ever emits ratios the API accepts', () => {
-    for (const size of ['1536x1024', '1024x1536', '1920x1080', '100x800', '800x100']) {
-      assert.ok(GEMINI_ASPECT_RATIOS.includes(geminiAspectRatio(size).value), size);
-    }
-  });
-});
-
-describe('extensionForMimeType', () => {
-  it('maps the image types a provider may return', () => {
-    assert.equal(extensionForMimeType('image/png'), '.png');
-    assert.equal(extensionForMimeType('image/jpeg'), '.jpg');
-    assert.equal(extensionForMimeType('image/webp'), '.webp');
-  });
-
-  it('ignores charset parameters and casing', () => {
-    assert.equal(extensionForMimeType('IMAGE/JPEG; charset=binary'), '.jpg');
-  });
-
-  it('falls back to .png for anything unrecognized', () => {
-    assert.equal(extensionForMimeType(undefined), '.png');
-    assert.equal(extensionForMimeType('application/octet-stream'), '.png');
-  });
-});
-
-describe('resolveOutputPath', () => {
-  it('names the default file after the bytes actually returned', () => {
-    const resolved = resolveOutputPath({ defaultBase: './generated-1', mimeType: 'image/jpeg' });
-
-    assert.equal(resolved.path, './generated-1.jpg');
-    assert.equal(resolved.warning, undefined);
-  });
-
-  it('honors an explicit path but flags an extension mismatch', () => {
-    const resolved = resolveOutputPath({ requested: 'logo.png', mimeType: 'image/webp' });
-
-    assert.equal(resolved.path, 'logo.png');
-    assert.match(resolved.warning, /image\/webp/);
-  });
-
-  it('stays quiet when the extension already matches', () => {
-    assert.equal(resolveOutputPath({ requested: 'logo.png', mimeType: 'image/png' }).warning, undefined);
-  });
-
-  it('appends an extension when the requested path has none', () => {
-    assert.equal(resolveOutputPath({ requested: 'logo', mimeType: 'image/png' }).path, 'logo.png');
-  });
-});
-
-describe('imageDimensions', () => {
-  const png = (w, h) => {
-    const b = Buffer.alloc(24);
-    b.writeUInt32BE(0x89504e47, 0);
-    b.writeUInt32BE(w, 16);
-    b.writeUInt32BE(h, 20);
-    return b;
-  };
-
-  it('reads PNG dimensions', () => {
-    assert.deepEqual(imageDimensions(png(1536, 1024)), { width: 1536, height: 1024 });
-  });
-
-  it('reads JPEG dimensions from the start-of-frame marker', () => {
-    const b = Buffer.alloc(32, 0);
-    b[0] = 0xff; b[1] = 0xd8;          // SOI
-    b[2] = 0xff; b[3] = 0xe0;          // APP0, skipped via its length
-    b.writeUInt16BE(6, 4);
-    b[10] = 0xff; b[11] = 0xc0;        // SOF0
-    b.writeUInt16BE(17, 12);
-    b.writeUInt16BE(480, 15);          // height
-    b.writeUInt16BE(640, 17);          // width
-
-    assert.deepEqual(imageDimensions(b), { width: 640, height: 480 });
-  });
-
-  it('reads WebP VP8X canvas size', () => {
-    const b = Buffer.alloc(32, 0);
-    b.write('RIFF', 0, 'ascii');
-    b.write('WEBP', 8, 'ascii');
-    b.write('VP8X', 12, 'ascii');
-    b.writeUIntLE(1023, 24, 3);        // stored as width - 1
-    b.writeUIntLE(767, 27, 3);
-
-    assert.deepEqual(imageDimensions(b), { width: 1024, height: 768 });
-  });
-
-  it('returns null for formats it cannot parse, rather than guessing', () => {
-    assert.equal(imageDimensions(Buffer.alloc(4)), null);
-    assert.equal(imageDimensions(Buffer.alloc(64, 7)), null);
-  });
-});
-
-describe('describeSizeMismatch', () => {
-  it('reports a pixel-size substitution', () => {
-    // The observed case: 1024x1536 requested, 1402x1122 returned.
-    const warning = describeSizeMismatch({
-      requestedSize: '1024x1536',
-      actual: { width: 1402, height: 1122 },
-    });
-
-    assert.match(warning, /Requested 1024x1536 but the provider returned 1402x1122/);
-  });
-
-  it('stays quiet when the size matches', () => {
-    assert.equal(
-      describeSizeMismatch({ requestedSize: '1536x1024', actual: { width: 1536, height: 1024 } }),
-      undefined,
-    );
-  });
-
-  it('reports an aspect-ratio substitution within a rounding tolerance', () => {
-    assert.equal(
-      describeSizeMismatch({ aspectRatio: '16:9', actual: { width: 1920, height: 1080 } }),
-      undefined,
-    );
-    assert.match(
-      describeSizeMismatch({ aspectRatio: '16:9', actual: { width: 1024, height: 1024 } }),
-      /Requested aspect ratio 16:9/,
-    );
-  });
-
-  it('says nothing when dimensions could not be read', () => {
-    assert.equal(describeSizeMismatch({ requestedSize: '1024x1024', actual: null }), undefined);
-  });
-});

package/skills/content/xai-search/tests/smoke_test.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-SCRIPT="$ROOT_DIR/scripts/xai_search.sh"
-
-if [[ ! -x "$SCRIPT" ]]; then
-  chmod +x "$SCRIPT"
-fi
-
-# Best-effort: populate XAI_API_KEY from OpenClaw config if env not set
-if [[ -z "${XAI_API_KEY:-}" ]] && command -v jq &>/dev/null && [[ -f "$HOME/.openclaw/openclaw.json" ]]; then
-  XAI_API_KEY=$(jq -r '.skills.entries["xai-search"].apiKey // empty' "$HOME/.openclaw/openclaw.json" 2>/dev/null || true)
-  export XAI_API_KEY
-fi
-
-if [[ -z "${XAI_API_KEY:-}" ]]; then
-  echo "SKIP: XAI_API_KEY is not set (env or openclaw.json); smoke test is best-effort."
-  exit 0
-fi
-
-echo "Running web mode smoke test..."
-WEB_OUT="$("$SCRIPT" web "latest xAI updates" --domains x.ai)"
-if [[ -z "${WEB_OUT// }" ]]; then
-  echo "FAIL: web mode returned empty output"
-  exit 1
-fi
-
-echo "Running x mode smoke test..."
-X_OUT="$("$SCRIPT" x "xAI announcements" --handles xai --from 2025-01-01)"
-if [[ -z "${X_OUT// }" ]]; then
-  echo "FAIL: x mode returned empty output"
-  exit 1
-fi
-
-echo "PASS: smoke tests produced non-empty output for both modes."