@myclaw163/clawclaw-cli 0.6.54

package/src/commands/setup/openclaw.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from 'vitest';
+import { computeOpenclawPatch, resolveOpenclawConfigPath } from './openclaw.js';
+
+describe('computeOpenclawPatch', () => {
+  it('on empty config creates plugins.allow, entries.enabled, tools.alsoAllow', () => {
+    const r = computeOpenclawPatch({}, {});
+    expect(r.warnings).toEqual([]);
+    expect(r.next).toEqual({
+      plugins: { allow: ['clawclaw'], entries: { clawclaw: { enabled: true } } },
+      tools: { alsoAllow: ['clawclaw'] },
+    });
+    expect(r.changes).toHaveLength(3);
+  });
+
+  it('null/non-object current is treated as empty', () => {
+    const r1 = computeOpenclawPatch(null, {});
+    expect(r1.warnings).toEqual([]);
+    expect((r1.next as any).plugins.allow).toEqual(['clawclaw']);
+    const r2 = computeOpenclawPatch(['unexpected'], {});
+    expect(r2.warnings).toEqual([]);
+    expect((r2.next as any).plugins.allow).toEqual(['clawclaw']);
+  });
+
+  it('no-op when everything already present', () => {
+    const current = {
+      plugins: { allow: ['clawclaw'], entries: { clawclaw: { enabled: true } } },
+      tools: { profile: 'coding', alsoAllow: ['clawclaw'] },
+    };
+    const r = computeOpenclawPatch(current, {});
+    expect(r.changes).toEqual([]);
+    expect(r.warnings).toEqual([]);
+    expect(r.next).toEqual(current);
+  });
+
+  it('Set union into existing plugins.allow without dupes', () => {
+    const r = computeOpenclawPatch({ plugins: { allow: ['other'] } }, {});
+    expect((r.next as any).plugins.allow).toEqual(['other', 'clawclaw']);
+    expect(r.changes).toContain('add "clawclaw" to plugins.allow');
+  });
+
+  it('Set union into existing tools.alsoAllow without dupes', () => {
+    const r = computeOpenclawPatch({ tools: { profile: 'coding', alsoAllow: ['somethingElse'] } }, {});
+    expect((r.next as any).tools.alsoAllow).toEqual(['somethingElse', 'clawclaw']);
+    expect(r.changes).toContain('add "clawclaw" to tools.alsoAllow');
+  });
+
+  it('does not touch tools.profile, even when not coding', () => {
+    const r = computeOpenclawPatch({ tools: { profile: 'full' } }, {});
+    expect((r.next as any).tools.profile).toBe('full');
+  });
+
+  it('does not touch tools.profile when missing (no opinion-setting)', () => {
+    const r = computeOpenclawPatch({}, {});
+    expect((r.next as any).tools.profile).toBeUndefined();
+  });
+
+  it('warns and skips when plugins.allow is not an array', () => {
+    const r = computeOpenclawPatch({ plugins: { allow: 'oops' } }, {});
+    expect(r.warnings.some((w) => w.includes('plugins.allow'))).toBe(true);
+    // unchanged value
+    expect((r.next as any).plugins.allow).toBe('oops');
+  });
+
+  it('warns and skips when tools.alsoAllow is not an array', () => {
+    const r = computeOpenclawPatch({ tools: { alsoAllow: 'oops' } }, {});
+    expect(r.warnings.some((w) => w.includes('tools.alsoAllow'))).toBe(true);
+    expect((r.next as any).tools.alsoAllow).toBe('oops');
+  });
+
+  it('respects explicit enabled:false on entries.clawclaw', () => {
+    const r = computeOpenclawPatch(
+      { plugins: { entries: { clawclaw: { enabled: false } } } },
+      {},
+    );
+    expect((r.next as any).plugins.entries.clawclaw.enabled).toBe(false);
+    expect(r.warnings.some((w) => w.includes('explicitly false'))).toBe(true);
+    // and we did not mark a change for it
+    expect(r.changes.some((c) => c.includes('enabled = true'))).toBe(false);
+  });
+
+  it('--skip-plugins-allow leaves plugins untouched, still patches tools', () => {
+    const r = computeOpenclawPatch({}, { skipPluginsAllow: true });
+    expect((r.next as any).plugins).toBeUndefined();
+    expect((r.next as any).tools.alsoAllow).toEqual(['clawclaw']);
+  });
+
+  it('--skip-tools-allow leaves tools untouched, still patches plugins', () => {
+    const r = computeOpenclawPatch({}, { skipToolsAllow: true });
+    expect((r.next as any).tools).toBeUndefined();
+    expect((r.next as any).plugins.allow).toEqual(['clawclaw']);
+  });
+
+  it('preserves unrelated top-level keys', () => {
+    const r = computeOpenclawPatch(
+      { models: { mode: 'replace' }, channels: { telegram: { enabled: true } } },
+      {},
+    );
+    expect((r.next as any).models).toEqual({ mode: 'replace' });
+    expect((r.next as any).channels).toEqual({ telegram: { enabled: true } });
+  });
+});
+
+describe('resolveOpenclawConfigPath', () => {
+  it('uses OPENCLAW_HOME when set', () => {
+    const p = resolveOpenclawConfigPath({ OPENCLAW_HOME: '/tmp/oc' });
+    expect(p.replace(/\\/g, '/')).toBe('/tmp/oc/openclaw.json');
+  });
+
+  it('falls back to ~/.openclaw/openclaw.json', () => {
+    const p = resolveOpenclawConfigPath({});
+    expect(p.endsWith('openclaw.json')).toBe(true);
+    expect(p.includes('.openclaw')).toBe(true);
+  });
+});

package/src/commands/setup/openclaw.ts

@@ -0,0 +1,147 @@
+/**
+ * `ccl setup openclaw` — install recommended OpenClaw config snippet.
+ *
+ * Pure function `computeOpenclawPatch` is exported for tests.
+ * IO / diff / atomic write / backup is delegated to lib/host-config-patcher.ts.
+ */
+
+import { Command } from 'commander';
+import { homedir } from 'os';
+import { join } from 'path';
+import {
+  runHostConfigSetup,
+  unionArrayField,
+  type HostPatchResult,
+} from '../../lib/host-config-patcher.js';
+
+export const PLUGIN_ID = 'clawclaw';
+
+export interface ComputeOpenclawPatchOpts {
+  skipPluginsAllow?: boolean;
+  skipToolsAllow?: boolean;
+}
+
+export function resolveOpenclawConfigPath(env: NodeJS.ProcessEnv = process.env): string {
+  const home = env.OPENCLAW_HOME?.trim();
+  if (home) return join(home, 'openclaw.json');
+  return join(homedir(), '.openclaw', 'openclaw.json');
+}
+
+/** Pure: compute the minimal additive patch to make `clawclaw` work under `coding` profile. */
+export function computeOpenclawPatch(current: unknown, opts: ComputeOpenclawPatchOpts): HostPatchResult {
+  const changes: string[] = [];
+  const warnings: string[] = [];
+  const cfg: Record<string, unknown> =
+    current !== null && typeof current === 'object' && !Array.isArray(current)
+      ? { ...(current as Record<string, unknown>) }
+      : {};
+
+  // ── plugins.allow + plugins.entries.clawclaw.enabled ──────────────────
+  if (!opts.skipPluginsAllow) {
+    const plugins: Record<string, unknown> =
+      cfg.plugins !== null && typeof cfg.plugins === 'object' && !Array.isArray(cfg.plugins)
+        ? { ...(cfg.plugins as Record<string, unknown>) }
+        : {};
+
+    const allowResult = unionArrayField(plugins.allow, PLUGIN_ID);
+    if ('warning' in allowResult) {
+      warnings.push(`plugins.allow ${allowResult.warning}`);
+    } else {
+      if (allowResult.added) {
+        if (plugins.allow === undefined) {
+          changes.push(`create plugins.allow with ["${PLUGIN_ID}"]`);
+        } else {
+          changes.push(`add "${PLUGIN_ID}" to plugins.allow`);
+        }
+      }
+      plugins.allow = allowResult.next;
+    }
+
+    const entries: Record<string, unknown> =
+      plugins.entries !== null && typeof plugins.entries === 'object' && !Array.isArray(plugins.entries)
+        ? { ...(plugins.entries as Record<string, unknown>) }
+        : {};
+    const existingEntry =
+      entries[PLUGIN_ID] !== null && typeof entries[PLUGIN_ID] === 'object' && !Array.isArray(entries[PLUGIN_ID])
+        ? { ...(entries[PLUGIN_ID] as Record<string, unknown>) }
+        : {};
+
+    if (existingEntry.enabled === false) {
+      warnings.push(
+        `plugins.entries.${PLUGIN_ID}.enabled is explicitly false; not flipping it on. Remove the line manually if you want it enabled.`,
+      );
+    } else if (existingEntry.enabled !== true) {
+      existingEntry.enabled = true;
+      entries[PLUGIN_ID] = existingEntry;
+      plugins.entries = entries;
+      changes.push(`set plugins.entries.${PLUGIN_ID}.enabled = true (equivalent to: openclaw plugins enable ${PLUGIN_ID})`);
+    }
+
+    cfg.plugins = plugins;
+  }
+
+  // ── tools.alsoAllow ────────────────────────────────────────────────────
+  if (!opts.skipToolsAllow) {
+    const tools: Record<string, unknown> =
+      cfg.tools !== null && typeof cfg.tools === 'object' && !Array.isArray(cfg.tools)
+        ? { ...(cfg.tools as Record<string, unknown>) }
+        : {};
+
+    const alsoAllowResult = unionArrayField(tools.alsoAllow, PLUGIN_ID);
+    if ('warning' in alsoAllowResult) {
+      warnings.push(`tools.alsoAllow ${alsoAllowResult.warning}`);
+    } else {
+      if (alsoAllowResult.added) {
+        if (tools.alsoAllow === undefined) {
+          changes.push(`create tools.alsoAllow with ["${PLUGIN_ID}"]`);
+        } else {
+          changes.push(`add "${PLUGIN_ID}" to tools.alsoAllow`);
+        }
+      }
+      tools.alsoAllow = alsoAllowResult.next;
+    }
+
+    cfg.tools = tools;
+  }
+
+  return { next: cfg, changes, warnings };
+}
+
+export function createSetupOpenclawSubcommand(): Command {
+  return new Command('openclaw')
+    .description('Install recommended OpenClaw config (plugins.allow + tools.alsoAllow) for the clawclaw plugin.')
+    .option('-y, --yes', 'Apply changes (default is dry-run with diff preview)')
+    .option('--print', 'Only print the recommended JSON patch; do not read or write files')
+    .option('--config <path>', 'Override openclaw.json path (default: $OPENCLAW_HOME/openclaw.json or ~/.openclaw/openclaw.json)')
+    .option('--skip-plugins-allow', "Do not touch plugins.allow / plugins.entries.clawclaw")
+    .option('--skip-tools-allow', "Do not touch tools.alsoAllow")
+    .option('--no-backup', 'Do not write a timestamped .bak.* before applying')
+    .action((opts: {
+      yes?: boolean;
+      print?: boolean;
+      config?: string;
+      skipPluginsAllow?: boolean;
+      skipToolsAllow?: boolean;
+      backup?: boolean;
+    }) => {
+      const result = runHostConfigSetup(
+        {
+          hostName: 'OpenClaw',
+          resolveConfigPath: () => resolveOpenclawConfigPath(),
+          computePatch: (current, hostOpts) => computeOpenclawPatch(current, hostOpts),
+        },
+        {
+          skipPluginsAllow: opts.skipPluginsAllow,
+          skipToolsAllow: opts.skipToolsAllow,
+        },
+        {
+          yes: opts.yes,
+          print: opts.print,
+          configPath: opts.config,
+          backup: opts.backup,
+        },
+      );
+      for (const line of result.output) console.log(line);
+      if (result.exitCode !== 0) process.exit(result.exitCode);
+    });
+}

package/src/commands/skill.ts

@@ -0,0 +1,128 @@
+// src/commands/skill.ts
+import { Command } from 'commander';
+import { spawnSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function getSkillsCli(): string {
+  try {
+    return require.resolve('skills/bin/cli.mjs');
+  } catch {
+    return '';
+  }
+}
+
+/** Resolve the built-in clawclaw skill shipped with this CLI package. */
+function resolveBuiltinSkill(): string {
+  // Priority: same repo layout (src/commands/skill.ts → ../../skills/clawclaw)
+  // Fallback: installed package layout (node_modules/@myclaw163/clawclaw-cli/skills/clawclaw)
+  // Also try legacy bare package name for backward compat during upgrade transition.
+  const devPath = join(__dirname, '..', '..', 'skills', 'clawclaw');
+  if (existsSync(join(devPath, 'SKILL.md'))) return devPath;
+  try {
+    const pkgRoot = dirname(require.resolve('@myclaw163/clawclaw-cli/package.json'));
+    return join(pkgRoot, 'skills', 'clawclaw');
+  } catch {
+    try {
+      const pkgRoot = dirname(require.resolve('clawclaw-cli/package.json'));
+      return join(pkgRoot, 'skills', 'clawclaw');
+    } catch {
+      return devPath;
+    }
+  }
+}
+
+/** Read the skill name from a directory's SKILL.md frontmatter. Returns null if not found. */
+export function readSkillName(dir: string): string | null {
+  const md = join(dir, 'SKILL.md');
+  if (!existsSync(md)) return null;
+  const content = readFileSync(md, 'utf8');
+  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  for (const line of m[1].split(/\r?\n/)) {
+    const kv = line.match(/^\s*name\s*:\s*(.+)\s*$/i);
+    if (kv) return kv[1].trim().replace(/^["']|["']$/g, '');
+  }
+  return null;
+}
+
+function runSkillsCli(args: string[]): { ok: boolean; err?: string } {
+  const cliBin = getSkillsCli();
+  if (!cliBin) return { ok: false, err: 'skills CLI not found. Ensure the "skills" package is installed.' };
+
+  const result = spawnSync(process.execPath, [cliBin, ...args], {
+    stdio: 'inherit',
+    timeout: 30_000,
+  });
+
+  if (result.error) return { ok: false, err: result.error.message };
+  if (result.status !== 0) return { ok: false, err: `skills CLI exited with code ${result.status}` };
+  return { ok: true };
+}
+
+export function createSkillCommand(): Command {
+  const cmd = new Command('skill')
+    .description('Install and manage agent skills');
+
+  // ─── install ───
+  cmd.command('install [path]')
+    .description('Register a skill directory with the agent. Use --builtin for the default clawclaw skill.')
+    .option('--builtin', 'install the built-in clawclaw skill shipped with this CLI')
+    .option('-g, --global', 'install globally', true)
+    .option('-y, --yes', 'skip confirmation prompts', true)
+    .action(async (rawPath: string | undefined, opts: { builtin?: boolean; global?: boolean; yes?: boolean }) => {
+      let absPath: string;
+      if (opts.builtin) {
+        absPath = resolveBuiltinSkill();
+      } else if (rawPath) {
+        absPath = resolve(rawPath);
+      } else {
+        console.error(JSON.stringify({ error: 'missing_path', message: 'Specify a path or use --builtin for the default clawclaw skill.' }, null, 2));
+        process.exit(1);
+      }
+
+      if (!existsSync(absPath)) {
+        console.error(JSON.stringify({ error: 'skill_not_found', message: `Skill directory not found: ${absPath}` }, null, 2));
+        process.exit(1);
+      }
+
+      const args = ['add', absPath];
+      if (opts.global) args.push('-g');
+      if (opts.yes) args.push('-y');
+      const r = runSkillsCli(args);
+      if (!r.ok) {
+        console.error(JSON.stringify({ error: 'skill_install_failed', message: r.err }, null, 2));
+        process.exit(1);
+      }
+    });
+
+  // ─── uninstall ───
+  cmd.command('uninstall <path>')
+    .description('Unregister a skill from the agent (wraps skills remove)')
+    .option('-g, --global', 'remove from global scope', true)
+    .option('-y, --yes', 'skip confirmation prompts', true)
+    .action(async (rawPath: string, opts: { global?: boolean; yes?: boolean }) => {
+      const absPath = resolve(rawPath);
+      const name = readSkillName(absPath);
+      if (!name) {
+        console.error(JSON.stringify({ error: 'skill_name_missing', message: `No valid SKILL.md with a name found in ${absPath}` }, null, 2));
+        process.exit(1);
+      }
+      const args = ['remove', name];
+      if (opts.global) args.push('-g');
+      if (opts.yes) args.push('-y');
+      const r = runSkillsCli(args);
+      if (!r.ok) {
+        console.error(JSON.stringify({ error: 'skill_uninstall_failed', message: r.err }, null, 2));
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/state.ts

@@ -0,0 +1,46 @@
+import { Command } from 'commander';
+import { GameClient } from '../lib/game-client.js';
+import { EventStore } from '../pipeline/event-store.js';
+
+function briefState(state: any): any {
+  const out: any = {
+    phase: state.phase,
+    you: state.you,
+    alive_count: state.alive_count,
+    task_progress: state.task_progress,
+  };
+  if (state.new_events?.length) out.new_events = state.new_events;
+  if (state.corpses?.length) out.corpses = state.corpses;
+  if (state.meeting) {
+    out.meeting = {
+      caller: state.meeting.caller,
+      sub_phase: state.meeting.sub_phase,
+      current_speaker: state.meeting.current_speaker,
+      speeches: state.meeting.speeches_so_far ?? state.meeting.speeches ?? {},
+      speech_skipped: state.meeting.speech_skipped,
+      votes_submitted: state.meeting.votes_submitted,
+      alive_players: state.meeting.alive_players,
+    };
+  }
+  return out;
+}
+
+export function createStateCommand(): Command {
+  return new Command('state')
+    .alias('s')
+    .description('Get current game state')
+    .option('-f, --full', 'Show full state (default: brief)')
+    .action(async (opts) => {
+      const client = GameClient.fromAuth();
+      await client.discoverGameServer();
+      const state = await client.getGameState();
+      if (!state) {
+        console.log(JSON.stringify({ status: 'no_active_game' }));
+        return;
+      }
+      const store = EventStore.forActiveAccount();
+      store.appendNewEvents((state as any).new_events);
+      const output = opts.full ? state : briefState(state);
+      console.log(JSON.stringify(output, null, 2));
+    });
+}

package/src/commands/strategy.test.ts

@@ -0,0 +1,135 @@
+// src/commands/strategy.test.ts
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { createStrategyCommand } from './strategy.js';
+
+let ws: string;
+let logs: string[];
+let errs: string[];
+
+beforeEach(() => {
+  ws = mkdtempSync(join(tmpdir(), 'ccl-strategy-cmd-'));
+  process.env.CLAWCLAW_WORKSPACE_DIR = ws;
+  logs = []; errs = [];
+  vi.spyOn(console, 'log').mockImplementation((...a) => { logs.push(a.join(' ')); });
+  vi.spyOn(console, 'error').mockImplementation((...a) => { errs.push(a.join(' ')); });
+  vi.spyOn(process, 'exit').mockImplementation((() => { throw new Error('process.exit'); }) as any);
+});
+
+afterEach(() => {
+  delete process.env.CLAWCLAW_WORKSPACE_DIR;
+  vi.restoreAllMocks();
+  rmSync(ws, { recursive: true, force: true });
+});
+
+async function run(argv: string[]) {
+  const cmd = createStrategyCommand();
+  await cmd.parseAsync(['node', 'ccl', ...argv]);
+}
+
+describe('strategy command', () => {
+  describe('--export', () => {
+    it('should export a valid strategy', async () => {
+      await run(['--export', 'task-only']);
+
+      const strategyFile = join(ws, 'strategies', 'task-only.ts');
+      expect(logs[0]).toContain('task-only');
+      expect(logs[0]).toContain('exported');
+
+      const content = readFileSync(strategyFile, 'utf8');
+      expect(content).toContain('// Exported from task-only@');
+      expect(content).toContain("from '@myclaw163/clawclaw-cli'");
+    });
+
+    it('should export with --force to overwrite', async () => {
+      // First export
+      await run(['--export', 'task-only']);
+
+      // Modify the file
+      const strategyFile = join(ws, 'strategies', 'task-only.ts');
+      writeFileSync(strategyFile, '// customized', 'utf8');
+
+      // Re-export with --force
+      await run(['--export', 'task-only', '--force']);
+
+      const content = readFileSync(strategyFile, 'utf8');
+      expect(content).toContain('// Exported from task-only@');
+    });
+
+    it('should export a formerly goal-based strategy with its knowledge sidecar', async () => {
+      await run(['--export', 'kill-lone']);
+
+      expect(existsSync(join(ws, 'strategies', 'kill-lone.ts'))).toBe(true);
+      expect(existsSync(join(ws, 'strategies', 'kill-lone.knowledge.md'))).toBe(true);
+    });
+
+    it('should reject non-existent strategies', async () => {
+      await expect(run(['--export', 'non-existent'])).rejects.toThrow('process.exit');
+
+      expect(errs[0]).toContain('export_failed');
+      expect(errs[0]).toContain('not found');
+    });
+
+    it('should warn about other stale strategies after export', async () => {
+      // Export two strategies
+      await run(['--export', 'task-only']);
+      await run(['--export', 'kill-lone']);
+      logs = []; errs = [];
+
+      // Tamper kill-lone's hash to make it stale
+      const manifestFile = join(ws, 'strategies', '.official', 'manifest.json');
+      const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
+      manifest['kill-lone'].sourceHash = 'stale';
+      writeFileSync(manifestFile, JSON.stringify(manifest), 'utf8');
+
+      // Re-export task-only — should warn about kill-lone being stale
+      await run(['--export', 'task-only', '--force']);
+
+      expect(errs.join(' ')).toContain('kill-lone');
+      expect(errs.join(' ')).toContain('提示');
+    });
+  });
+
+  describe('--info', () => {
+    it('should show strategy info', async () => {
+      await run(['--info', 'task-only']);
+
+      expect(logs[0]).toContain('"id": "task-only"');
+      expect(logs[0]).toContain('"description"');
+    });
+
+    it('should show knowledge contract if available', async () => {
+      await run(['--info', 'task-report']);
+
+      const output = JSON.parse(logs[0]);
+      expect(output.id).toBe('task-report');
+      expect(output.description).toBeDefined();
+      // knowledge might be null if no .knowledge.md file exists
+    });
+
+    it('should reject non-existent strategies', async () => {
+      await expect(run(['--info', 'non-existent'])).rejects.toThrow('process.exit');
+
+      expect(errs[0]).toContain('unknown_strategy');
+      expect(errs[0]).toContain('non-existent');
+    });
+  });
+
+  describe('--list', () => {
+    it('should list all available strategies', async () => {
+      await run(['--list']);
+
+      const output = JSON.parse(logs[0]);
+      expect(output.strategies).toBeDefined();
+      expect(Array.isArray(output.strategies)).toBe(true);
+      expect(output.strategies.length).toBeGreaterThan(0);
+
+      // Check that task-only is in the list
+      const taskOnly = output.strategies.find((s: any) => s.id === 'task-only');
+      expect(taskOnly).toBeDefined();
+      expect(taskOnly.description).toBeDefined();
+    });
+  });
+});