claws-code 0.8.0

package/extension/src/topic-registry.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { matchTopic } from './topic-utils';
+import {
+  WorkerBootV1, WorkerPhaseV1, WorkerEventV1, WorkerHeartbeatV1, WorkerCompleteV1,
+  CmdApproveV1, CmdRejectV1, CmdAbortV1, CmdPauseV1, CmdResumeV1,
+  CmdSetPhaseV1, CmdSpawnV1, CmdInjectTextV1,
+  SystemPeerJoinedV1, SystemPeerLeftV1, SystemPeerStaleV1,
+  SystemGateFiredV1, SystemBudgetWarningV1, SystemMalformedReceivedV1,
+  VehicleStateV1, VehicleContentV1, CommandStartV1, CommandEndV1,
+  CmdAckV1, PipelineStepV1, RpcRequestV1, RpcResponseV1, WaveHarvestedV1,
+  TerminalClosedV1,
+} from './event-schemas';
+
+export { matchTopic };
+
+export const TOPIC_REGISTRY: ReadonlyArray<{ pattern: string; schema: z.ZodTypeAny }> = [
+  { pattern: 'worker.*.boot',              schema: WorkerBootV1 },
+  { pattern: 'worker.*.phase',             schema: WorkerPhaseV1 },
+  { pattern: 'worker.*.event',             schema: WorkerEventV1 },
+  { pattern: 'worker.*.heartbeat',         schema: WorkerHeartbeatV1 },
+  { pattern: 'worker.*.complete',          schema: WorkerCompleteV1 },
+  { pattern: 'cmd.*.approve',              schema: CmdApproveV1 },
+  { pattern: 'cmd.*.reject',               schema: CmdRejectV1 },
+  { pattern: 'cmd.*.abort',                schema: CmdAbortV1 },
+  { pattern: 'cmd.*.pause',                schema: CmdPauseV1 },
+  { pattern: 'cmd.*.resume',               schema: CmdResumeV1 },
+  { pattern: 'cmd.*.set_phase',            schema: CmdSetPhaseV1 },
+  { pattern: 'cmd.*.spawn',                schema: CmdSpawnV1 },
+  { pattern: 'cmd.*.inject_text',          schema: CmdInjectTextV1 },
+  { pattern: 'system.peer.joined',         schema: SystemPeerJoinedV1 },
+  { pattern: 'system.peer.left',           schema: SystemPeerLeftV1 },
+  { pattern: 'system.peer.stale',          schema: SystemPeerStaleV1 },
+  { pattern: 'system.gate.fired',          schema: SystemGateFiredV1 },
+  { pattern: 'system.budget.warning',      schema: SystemBudgetWarningV1 },
+  { pattern: 'system.malformed.received',  schema: SystemMalformedReceivedV1 },
+  { pattern: 'vehicle.*.state',            schema: VehicleStateV1 },
+  { pattern: 'vehicle.*.created',          schema: VehicleStateV1 },
+  { pattern: 'vehicle.*.closed',           schema: VehicleStateV1 },
+  { pattern: 'vehicle.*.content',          schema: VehicleContentV1 },
+  { pattern: 'command.*.start',            schema: CommandStartV1 },
+  { pattern: 'command.*.end',              schema: CommandEndV1 },
+  { pattern: 'command.*.timeout',          schema: CommandEndV1 },
+  { pattern: 'error.*.crash',              schema: z.object({
+    terminalId: z.string().min(1),
+    exitCode:   z.number().int().nullable(),
+    ts:         z.string().datetime(),
+  }) },
+  { pattern: 'wave.*.harvested',           schema: WaveHarvestedV1 },
+  { pattern: 'wave.*.violation',           schema: z.record(z.unknown()) },
+  { pattern: 'wave.*.orphan_detected',     schema: z.record(z.unknown()) },
+  { pattern: 'wave.**',                    schema: z.record(z.unknown()) },
+  { pattern: 'cmd.*.ack',                  schema: CmdAckV1 },
+  { pattern: 'pipeline.*.step.*',          schema: PipelineStepV1 },
+  { pattern: 'pipeline.*.created',         schema: z.record(z.unknown()) },
+  { pattern: 'pipeline.*.closed',          schema: z.record(z.unknown()) },
+  { pattern: 'rpc.*.request',              schema: RpcRequestV1 },
+  { pattern: 'rpc.response.**',            schema: RpcResponseV1 },
+  { pattern: 'system.terminal.closed',     schema: TerminalClosedV1 },
+];
+
+/**
+ * Returns the Zod data schema for the given topic, or null if no schema
+ * is registered for the topic pattern.
+ */
+export function schemaForTopic(topic: string): z.ZodTypeAny | null {
+  for (const entry of TOPIC_REGISTRY) {
+    if (matchTopic(topic, entry.pattern)) return entry.schema;
+  }
+  return null;
+}

package/extension/src/topic-utils.ts

@@ -0,0 +1,46 @@
+// Standalone topic-pattern matching utilities.
+// Imported by both peer-registry.ts and topic-registry.ts to avoid a
+// circular dependency that would arise if topic-registry imported from
+// peer-registry while server.ts imports both.
+
+/**
+ * Match a concrete dot-delimited topic against a subscription pattern.
+ *
+ * Rules (segments separated by `.`):
+ *   - `*`  matches exactly one segment
+ *   - `**` matches one or more segments (greedy; at least one segment)
+ *   - any other segment must match literally
+ *
+ * Examples:
+ *   matchTopic('task.started.p1', 'task.*.p1')    === true
+ *   matchTopic('task.started.p1', 'task.**')      === true
+ *   matchTopic('task.started',    'task.**')      === true
+ *   matchTopic('task',            'task.**')      === false
+ *   matchTopic('worker.online',   'worker.*')     === true
+ *   matchTopic('worker.online.p1','worker.*')     === false
+ */
+export function matchTopic(topic: string, pattern: string): boolean {
+  const t = topic.split('.');
+  const p = pattern.split('.');
+  return matchSegments(t, 0, p, 0);
+}
+
+function matchSegments(t: string[], ti: number, p: string[], pi: number): boolean {
+  while (pi < p.length) {
+    const seg = p[pi];
+    if (seg === '**') {
+      if (pi === p.length - 1) {
+        return ti < t.length;
+      }
+      for (let k = ti + 1; k <= t.length; k++) {
+        if (matchSegments(t, k, p, pi + 1)) return true;
+      }
+      return false;
+    }
+    if (ti >= t.length) return false;
+    if (seg !== '*' && seg !== t[ti]) return false;
+    ti++;
+    pi++;
+  }
+  return ti === t.length;
+}

package/extension/src/transport.ts

@@ -0,0 +1,45 @@
+// extension/src/transport.ts
+// Cross-platform IPC endpoint computation for Claws.
+// On Unix (darwin/linux): workspace/.claws/claws.sock
+// On Windows: \\.\pipe\claws-<sha256[0:8] of workspace root>
+
+import * as crypto from 'crypto';
+import * as path from 'path';
+import type { NodePlatform } from './platform';
+
+export type Endpoint = string;
+
+/**
+ * Compute the IPC endpoint for a given workspace root.
+ *
+ * Decision 1 (v0.8 blueprint): Windows uses named pipes because Unix sockets
+ * are not reliably available on Windows. The sha256[0:8] hash provides a
+ * stable, collision-resistant pipe name that encodes workspace identity into
+ * the flat \\.\pipe\ namespace. Windows paths are lowercased before hashing
+ * because NTFS is case-insensitive.
+ *
+ * @param workspaceRoot  absolute path to the VS Code workspace folder
+ * @param platform       injectable for testing; defaults to process.platform
+ */
+export function getServerEndpoint(
+  workspaceRoot: string,
+  platform: NodePlatform | string = process.platform,
+): Endpoint {
+  if (platform === 'win32') {
+    const hash = crypto
+      .createHash('sha256')
+      .update(workspaceRoot.toLowerCase())
+      .digest('hex')
+      .slice(0, 8);
+    return `\\\\.\\pipe\\claws-${hash}`;
+  }
+  return path.join(workspaceRoot, '.claws', 'claws.sock');
+}
+
+/**
+ * True when the endpoint is a Windows named pipe rather than a filesystem path.
+ * Used to guard fs.unlink / fs.chmod calls that are no-ops for named pipes.
+ */
+export function isNamedPipe(endpoint: Endpoint): boolean {
+  return endpoint.startsWith('\\\\.\\pipe\\') || endpoint.startsWith('//./pipe/');
+}

package/extension/src/uninstall-cleanup.ts

@@ -0,0 +1,232 @@
+// Uninstall-cleanup command implementation.
+//
+// Inventories Claws-installed files across the currently-open workspace
+// folders and, on explicit per-folder confirmation, removes only what was
+// actually installed. Never touches files Claws didn't put there (edits to
+// JSON / markdown surgically strip only the `claws` entries).
+
+import * as vscode from 'vscode';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// M-30: atomic write helper (tmp + renameSync) — prevents partial file on kill mid-write.
+// Inline implementation (no cross-package import needed) — mirrors atomic-file.mjs.
+// F3: open+writeSync+fsyncSync+close before rename for durability on power-cut.
+let _atomicNonce = 0;
+function writeAtomic(filePath: string, content: string): void {
+  const tmp = `${filePath}.claws-tmp.${process.pid}-${++_atomicNonce}`;
+  let _fd: number | null = null;
+  try {
+    _fd = fs.openSync(tmp, 'w', 0o644);
+    fs.writeSync(_fd, content);
+    fs.fsyncSync(_fd);
+    fs.closeSync(_fd);
+    _fd = null;
+    fs.renameSync(tmp, filePath);
+  } catch (err) {
+    if (_fd !== null) { try { fs.closeSync(_fd); } catch { /* ignore */ } }
+    try { fs.unlinkSync(tmp); } catch { /* ignore */ }
+    throw err;
+  }
+}
+
+export interface CleanupAction {
+  action: 'rmdir' | 'rm' | 'edit-json' | 'edit-markdown';
+  path: string;
+  /** Extra context for edit-* actions. */
+  note?: string;
+}
+
+export interface CleanupResult {
+  removed: number;
+  failed: number;
+}
+
+/**
+ * Register the `claws.uninstallCleanup` command. The command:
+ *   1. Shows a modal warning
+ *   2. For each currently-open workspace folder, plans + confirms + executes
+ *   3. Prints a summary to the Output channel
+ *   4. Guides the user to uninstall the extension itself manually
+ */
+export function registerUninstallCleanupCommand(
+  context: vscode.ExtensionContext,
+  logger: (msg: string) => void,
+  showOutput: () => void,
+): void {
+  context.subscriptions.push(
+    vscode.commands.registerCommand('claws.uninstallCleanup', async () => {
+      const confirm = await vscode.window.showInformationMessage(
+        'Claws: Uninstall Cleanup — this will remove Claws-installed files from your currently-open workspace folders. The VS Code extension itself must be uninstalled manually afterwards. Continue?',
+        { modal: true },
+        'Continue',
+        'Cancel',
+      );
+      if (confirm !== 'Continue') return;
+
+      const folders = vscode.workspace.workspaceFolders ?? [];
+      if (folders.length === 0) {
+        vscode.window.showWarningMessage('Claws: no workspace folders open. Nothing to clean.');
+        return;
+      }
+
+      showOutput();
+      logger('');
+      logger('── Claws: Uninstall Cleanup ──');
+
+      const summary: string[] = [];
+      for (const folder of folders) {
+        const root = folder.uri.fsPath;
+        const plan = planCleanup(root);
+        if (plan.length === 0) {
+          logger(`[cleanup] ${root}: nothing to remove`);
+          continue;
+        }
+        const detail = plan.map((p) => `  ${p.action}: ${p.path}`).join('\n');
+        logger(`[cleanup] ${root}: planned removals:\n${detail}`);
+        const proceed = await vscode.window.showWarningMessage(
+          `Claws: clean up files in ${path.basename(root)}?\n\n${plan.map((p) => `${p.action}: ${path.relative(root, p.path)}`).join('\n')}`,
+          { modal: true },
+          'Remove',
+          'Skip',
+        );
+        if (proceed !== 'Remove') {
+          logger(`[cleanup] ${root}: SKIPPED by user`);
+          continue;
+        }
+        const results = executeCleanup(plan, logger);
+        summary.push(`${root}: ${results.removed} removed, ${results.failed} failed`);
+      }
+
+      logger('');
+      logger('── cleanup summary ──');
+      if (summary.length === 0) {
+        logger('no folders were cleaned');
+      } else {
+        for (const s of summary) logger(`  ${s}`);
+      }
+      logger('');
+      logger('Next step: uninstall the "Claws" extension from the VS Code Extensions panel.');
+      vscode.window.showInformationMessage(
+        'Claws cleanup complete. Uninstall the VS Code extension manually from the Extensions panel to finish.',
+      );
+    }),
+  );
+}
+
+/**
+ * Build a plan of cleanup actions for a single workspace folder. Returns an
+ * empty array if nothing Claws-installed is detected — the command uses this
+ * to skip folder confirmation prompts for folders with nothing to remove.
+ */
+export function planCleanup(root: string): CleanupAction[] {
+  const plan: CleanupAction[] = [];
+  const push = (a: CleanupAction) => plan.push(a);
+
+  const mcpJson = path.join(root, '.mcp.json');
+  if (fs.existsSync(mcpJson)) {
+    // Only target when it actually has a claws entry.
+    try {
+      const raw = fs.readFileSync(mcpJson, 'utf8');
+      const parsed = JSON.parse(raw) as { mcpServers?: Record<string, unknown> };
+      if (parsed.mcpServers && 'claws' in parsed.mcpServers) {
+        push({ action: 'edit-json', path: mcpJson, note: 'drop mcpServers.claws' });
+      }
+    } catch { /* malformed — skip */ }
+  }
+
+  const clawsBin = path.join(root, '.claws-bin');
+  if (fs.existsSync(clawsBin)) push({ action: 'rmdir', path: clawsBin });
+
+  const cmdsDir = path.join(root, '.claude', 'commands');
+  if (fs.existsSync(cmdsDir)) {
+    for (const entry of fs.readdirSync(cmdsDir)) {
+      if (entry.startsWith('claws-') && entry.endsWith('.md')) {
+        push({ action: 'rm', path: path.join(cmdsDir, entry) });
+      }
+    }
+  }
+
+  const rulesFile = path.join(root, '.claude', 'rules', 'claws-default-behavior.md');
+  if (fs.existsSync(rulesFile)) push({ action: 'rm', path: rulesFile });
+
+  for (const skill of ['claws-orchestration-engine', 'claws-prompt-templates', 'claws-wave-lead', 'claws-wave-subworker']) {
+    const p = path.join(root, '.claude', 'skills', skill);
+    if (fs.existsSync(p)) push({ action: 'rmdir', path: p });
+  }
+
+  const extensionsJson = path.join(root, '.vscode', 'extensions.json');
+  if (fs.existsSync(extensionsJson)) {
+    try {
+      const raw = fs.readFileSync(extensionsJson, 'utf8');
+      const parsed = JSON.parse(raw) as { recommendations?: unknown };
+      const recs = Array.isArray(parsed.recommendations) ? parsed.recommendations as string[] : [];
+      if (recs.includes('neunaha.claws')) {
+        push({ action: 'edit-json', path: extensionsJson, note: 'drop recommendations[neunaha.claws]' });
+      }
+    } catch { /* malformed — skip */ }
+  }
+
+  const claudeMd = path.join(root, 'CLAUDE.md');
+  if (fs.existsSync(claudeMd)) {
+    try {
+      const raw = fs.readFileSync(claudeMd, 'utf8');
+      if (raw.includes('<!-- CLAWS:BEGIN -->') && raw.includes('<!-- CLAWS:END -->')) {
+        push({ action: 'edit-markdown', path: claudeMd, note: 'strip CLAWS fenced block' });
+      }
+    } catch { /* ignore */ }
+  }
+
+  return plan;
+}
+
+/**
+ * Execute a cleanup plan. Each action runs in a try/catch so one failure
+ * does not abort the rest. Logs each operation's outcome and returns a
+ * tally for the summary line.
+ */
+export function executeCleanup(
+  plan: CleanupAction[],
+  logger: (msg: string) => void,
+): CleanupResult {
+  let removed = 0;
+  let failed = 0;
+  for (const action of plan) {
+    try {
+      if (action.action === 'rm') {
+        fs.unlinkSync(action.path);
+        logger(`[cleanup]   ✓ rm ${action.path}`);
+      } else if (action.action === 'rmdir') {
+        fs.rmSync(action.path, { recursive: true, force: true });
+        logger(`[cleanup]   ✓ rmdir ${action.path}`);
+      } else if (action.action === 'edit-json') {
+        const raw = fs.readFileSync(action.path, 'utf8');
+        const parsed = JSON.parse(raw) as Record<string, unknown>;
+        if (path.basename(action.path) === '.mcp.json') {
+          const servers = parsed.mcpServers as Record<string, unknown> | undefined;
+          if (servers) delete servers.claws;
+        } else if (path.basename(action.path) === 'extensions.json') {
+          const recs = parsed.recommendations as string[] | undefined;
+          if (Array.isArray(recs)) {
+            parsed.recommendations = recs.filter((r) => r !== 'neunaha.claws');
+          }
+        }
+        writeAtomic(action.path, JSON.stringify(parsed, null, 2) + '\n');
+        logger(`[cleanup]   ✓ edit-json ${action.path} (${action.note})`);
+      } else if (action.action === 'edit-markdown') {
+        const raw = fs.readFileSync(action.path, 'utf8');
+        const stripped = raw.replace(
+          /<!-- CLAWS:BEGIN -->[\s\S]*?<!-- CLAWS:END -->\n?/g,
+          '',
+        );
+        writeAtomic(action.path, stripped);
+        logger(`[cleanup]   ✓ edit-markdown ${action.path} (${action.note})`);
+      }
+      removed += 1;
+    } catch (err) {
+      logger(`[cleanup]   ✗ ${action.action} ${action.path} — ${(err as Error).message}`);
+      failed += 1;
+    }
+  }
+  return { removed, failed };
+}