@myclaw163/clawclaw-cli 0.6.65 → 0.6.67

package/src/commands/setup/index.ts

@@ -1,13 +1,13 @@
-import { Command } from 'commander';
-import { createSetupOpenclawSubcommand } from './openclaw.js';
-import { createSetupHermesSubcommand } from './hermes.js';
-import { createSetupCodexSubcommand } from './codex.js';
-
-export function createSetupCommand(): Command {
-  const setup = new Command('setup');
-  setup.description('Install recommended config snippets into agent host config files.');
-  setup.addCommand(createSetupOpenclawSubcommand());
-  setup.addCommand(createSetupHermesSubcommand());
-  setup.addCommand(createSetupCodexSubcommand());
-  return setup;
-}
+import { Command } from 'commander';
+import { createSetupOpenclawSubcommand } from './openclaw.js';
+import { createSetupHermesSubcommand } from './hermes.js';
+import { createSetupCodexSubcommand } from './codex.js';
+
+export function createSetupCommand(): Command {
+  const setup = new Command('setup');
+  setup.description('Install recommended config snippets into agent host config files.');
+  setup.addCommand(createSetupOpenclawSubcommand());
+  setup.addCommand(createSetupHermesSubcommand());
+  setup.addCommand(createSetupCodexSubcommand());
+  return setup;
+}

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

@@ -1,114 +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);
-  });
-});
+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

@@ -1,147 +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);
-    });
-}
+/**
+ * `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);
+    });
+}