@losclaws/cli 0.1.1

package/src/utils.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs/promises';
+
+import { CliError } from './errors.js';
+
+export function parseArgs(argv) {
+  const positionals = [];
+  const options = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+
+    if (token === '--') {
+      positionals.push(...argv.slice(index + 1));
+      break;
+    }
+
+    if (!token.startsWith('-') || token === '-') {
+      positionals.push(token);
+      continue;
+    }
+
+    if (token.startsWith('--no-')) {
+      options[toCamel(token.slice(5))] = false;
+      continue;
+    }
+
+    if (token.startsWith('--')) {
+      const [rawKey, inlineValue] = token.slice(2).split('=', 2);
+      const key = toCamel(rawKey);
+
+      if (inlineValue !== undefined) {
+        options[key] = inlineValue;
+        continue;
+      }
+
+      const next = argv[index + 1];
+      if (next !== undefined && !next.startsWith('-')) {
+        options[key] = next;
+        index += 1;
+      } else {
+        options[key] = true;
+      }
+      continue;
+    }
+
+    const flags = token.slice(1).split('');
+    for (let flagIndex = 0; flagIndex < flags.length; flagIndex += 1) {
+      const flag = flags[flagIndex];
+      const key = shortFlagMap[flag];
+      if (!key) {
+        throw new CliError(`Unknown short flag: -${flag}`);
+      }
+
+      const rest = flags.slice(flagIndex + 1).join('');
+      if (rest) {
+        options[key] = rest;
+        break;
+      }
+
+      const next = argv[index + 1];
+      if (next !== undefined && !next.startsWith('-') && shortFlagsWithValue.has(flag)) {
+        options[key] = next;
+        index += 1;
+      } else {
+        options[key] = true;
+      }
+    }
+  }
+
+  return { positionals, options };
+}
+
+export function toCamel(value) {
+  return value.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+export function indent(text, prefix = '  ') {
+  return String(text)
+    .split('\n')
+    .map((line) => `${prefix}${line}`)
+    .join('\n');
+}
+
+export function pretty(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+export function redactSecret(value, visible = 4) {
+  if (!value) {
+    return value;
+  }
+
+  if (value.length <= visible * 2) {
+    return `${value.slice(0, 1)}***${value.slice(-1)}`;
+  }
+
+  return `${value.slice(0, visible)}...${value.slice(-visible)}`;
+}
+
+export function sanitizeProfile(profile) {
+  return {
+    ...profile,
+    accessToken: redactSecret(profile.accessToken),
+    apiKey: redactSecret(profile.apiKey),
+  };
+}
+
+export function ensureNumber(value, label) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new CliError(`${label} must be a non-negative integer.`);
+  }
+  return parsed;
+}
+
+export function ensureString(value, label) {
+  if (!value || typeof value !== 'string') {
+    throw new CliError(`${label} is required.`);
+  }
+  return value;
+}
+
+export function maybeJson(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new CliError(`Invalid JSON: ${error.message}`);
+  }
+}
+
+export async function readJsonFile(path) {
+  try {
+    const raw = await fs.readFile(path, 'utf8');
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new CliError(`File not found: ${path}`);
+    }
+    if (error instanceof SyntaxError) {
+      throw new CliError(`Invalid JSON file: ${path}`);
+    }
+    throw error;
+  }
+}
+
+export async function readTextFile(path) {
+  try {
+    return await fs.readFile(path, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new CliError(`File not found: ${path}`);
+    }
+    throw error;
+  }
+}
+
+export function joinUrl(baseUrl, path, query = undefined) {
+  const url = new URL(path, ensureTrailingSlash(baseUrl));
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== undefined && value !== null && value !== '') {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+
+export function ensureTrailingSlash(value) {
+  return value.endsWith('/') ? value : `${value}/`;
+}
+
+export function summarizeEvent(payload) {
+  const parts = [];
+
+  if (payload.event_type) {
+    parts.push(payload.event_type);
+  } else if (payload.type) {
+    parts.push(payload.type);
+  } else if (payload.status) {
+    parts.push(payload.status);
+  } else {
+    parts.push('event');
+  }
+
+  if (payload.message) {
+    parts.push(payload.message);
+  } else if (Array.isArray(payload.events) && payload.events.length > 0) {
+    const messages = payload.events
+      .map((entry) => entry.message || entry.type)
+      .filter(Boolean)
+      .slice(0, 2);
+    if (messages.length > 0) {
+      parts.push(messages.join(' | '));
+    }
+  } else if (payload.pending_action?.prompt) {
+    parts.push(payload.pending_action.prompt);
+  }
+
+  if (payload.game_over && payload.result?.winner_team) {
+    parts.push(`winner_team=${payload.result.winner_team}`);
+  }
+
+  return parts.join(' — ');
+}
+
+const shortFlagMap = {
+  h: 'help',
+  j: 'json',
+  p: 'profile',
+};
+
+const shortFlagsWithValue = new Set(['p']);

package/test/config.test.js

@@ -0,0 +1,112 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import { clearedAuthProfile, configForDisplay, resolveRuntime } from '../src/config.js';
+
+test('resolveRuntime includes clawworkshop base URL from profile', () => {
+  const runtime = resolveRuntime(
+    {
+      profile: {
+        losclawsBaseUrl: 'https://losclaws.example',
+        clawarenaBaseUrl: 'https://arena.example',
+        clawworkshopBaseUrl: 'https://workshop.example',
+        accessToken: 'token-12345678',
+        apiKey: 'key-12345678',
+      },
+    },
+    {},
+  );
+
+  assert.equal(runtime.clawworkshopBaseUrl, 'https://workshop.example');
+});
+
+test('configForDisplay preserves clawworkshop base URL in visible profile data', () => {
+  const result = configForDisplay({
+    configPath: '/tmp/losclaws.json',
+    profileName: 'default',
+    profile: {
+      losclawsBaseUrl: 'https://losclaws.example',
+      clawarenaBaseUrl: 'https://arena.example',
+      clawworkshopBaseUrl: 'https://workshop.example',
+      accessToken: 'token-12345678',
+      apiKey: 'key-12345678',
+    },
+  });
+
+  assert.equal(result.data.clawworkshopBaseUrl, 'https://workshop.example');
+  assert.match(result.data.accessToken, /\.\.\./);
+  assert.match(result.data.apiKey, /\.\.\./);
+});
+
+test('clearedAuthProfile removes persisted auth while preserving endpoints', () => {
+  const result = clearedAuthProfile({
+    losclawsBaseUrl: 'https://losclaws.example',
+    clawarenaBaseUrl: 'https://arena.example',
+    clawworkshopBaseUrl: 'https://workshop.example',
+    accessToken: 'token-12345678',
+    apiKey: 'key-12345678',
+    subjectType: 'human',
+    agent: { id: 'agent-1' },
+    human: { id: 'human-1' },
+  });
+
+  assert.equal(result.losclawsBaseUrl, 'https://losclaws.example');
+  assert.equal(result.clawarenaBaseUrl, 'https://arena.example');
+  assert.equal(result.clawworkshopBaseUrl, 'https://workshop.example');
+  assert.equal(result.accessToken, '');
+  assert.equal(result.apiKey, '');
+  assert.equal(result.subjectType, '');
+  assert.equal(result.agent, null);
+  assert.equal(result.human, null);
+});
+
+test('auth logout clears saved credentials for the active profile', async () => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'losclaws-cli-test-'));
+  const configPath = path.join(tempDir, 'config.json');
+  const cliPath = fileURLToPath(new URL('../bin/losclaws.js', import.meta.url));
+
+  await fs.writeFile(
+    configPath,
+    `${JSON.stringify(
+      {
+        defaultProfile: 'default',
+        profiles: {
+          default: {
+            losclawsBaseUrl: 'https://losclaws.example',
+            clawarenaBaseUrl: 'https://arena.example',
+            clawworkshopBaseUrl: 'https://workshop.example',
+            accessToken: 'token-12345678',
+            apiKey: 'key-12345678',
+            subjectType: 'agent',
+            agent: { id: 'agent-1', name: 'tester' },
+            human: { id: 'human-1', name: 'ignored' },
+          },
+        },
+      },
+      null,
+      2,
+    )}\n`,
+    'utf8',
+  );
+
+  const result = spawnSync(process.execPath, [cliPath, 'auth', 'logout', '--config', configPath], {
+    encoding: 'utf8',
+  });
+
+  assert.equal(result.status, 0, result.stderr);
+
+  const saved = JSON.parse(await fs.readFile(configPath, 'utf8'));
+  assert.equal(saved.profiles.default.losclawsBaseUrl, 'https://losclaws.example');
+  assert.equal(saved.profiles.default.clawarenaBaseUrl, 'https://arena.example');
+  assert.equal(saved.profiles.default.clawworkshopBaseUrl, 'https://workshop.example');
+  assert.equal(saved.profiles.default.accessToken, '');
+  assert.equal(saved.profiles.default.apiKey, '');
+  assert.equal(saved.profiles.default.subjectType, '');
+  assert.equal(saved.profiles.default.agent, null);
+  assert.equal(saved.profiles.default.human, null);
+});

package/test/inspect.test.js

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { parseModelListOutput } from '../src/inspect.js';
+
+test('parseModelListOutput extracts models from nested JSON payloads', () => {
+  const models = parseModelListOutput(
+    JSON.stringify({
+      data: [
+        { id: 'gpt-5.4' },
+        { id: 'claude-sonnet-4.6' },
+      ],
+    }),
+  );
+
+  assert.deepEqual(models, ['claude-sonnet-4.6', 'gpt-5.4']);
+});
+
+test('parseModelListOutput filters noisy plain-text command output', () => {
+  const models = parseModelListOutput(`
+Usage: tool models
+gpt-5.4
+claude-sonnet-4.6
+error: ignored
+  `);
+
+  assert.deepEqual(models, ['claude-sonnet-4.6', 'gpt-5.4']);
+});

package/test/utils.test.js

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { normalizeEvent } from '../src/sse.js';
+import { parseArgs, summarizeEvent, toCamel } from '../src/utils.js';
+
+test('parseArgs supports kebab-case and no flags', () => {
+  const { positionals, options } = parseArgs([
+    'arena',
+    'rooms',
+    'create',
+    '--game-type-id',
+    '1',
+    '--no-save',
+    '--json',
+  ]);
+
+  assert.deepEqual(positionals, ['arena', 'rooms', 'create']);
+  assert.equal(options.gameTypeId, '1');
+  assert.equal(options.save, false);
+  assert.equal(options.json, true);
+});
+
+test('toCamel converts kebab-case names', () => {
+  assert.equal(toCamel('game-type-id'), 'gameTypeId');
+});
+
+test('normalizeEvent parses JSON payloads', () => {
+  const result = normalizeEvent({
+    id: '5',
+    type: 'game_event',
+    data: ['{"game_over":true,"result":{"winner_team":"good"}}'],
+  });
+
+  assert.equal(result.id, '5');
+  assert.equal(result.type, 'game_event');
+  assert.equal(result.data.game_over, true);
+  assert.equal(result.data.result.winner_team, 'good');
+});
+
+test('summarizeEvent prefers event type and message', () => {
+  const summary = summarizeEvent({
+    event_type: 'phase_change',
+    message: 'Day 1 begins.',
+  });
+
+  assert.equal(summary, 'phase_change — Day 1 begins.');
+});