clawmini 0.0.8 → 0.0.9

package/src/adapter-google-chat/inbound-cache.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  recordInbound,
+  resolveInbound,
+  INBOUND_TTL_MS,
+  _resetInboundCacheForTests,
+} from './inbound-cache.js';
+
+describe('inbound-cache', () => {
+  beforeEach(() => {
+    _resetInboundCacheForTests();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('records and resolves an inbound by gchatMessageName', () => {
+    recordInbound({
+      gchatMessageName: 'spaces/x/messages/m1',
+      gchatThreadName: 'spaces/x/threads/t1',
+    });
+    const record = resolveInbound('spaces/x/messages/m1');
+    expect(record).toMatchObject({
+      gchatMessageName: 'spaces/x/messages/m1',
+      gchatThreadName: 'spaces/x/threads/t1',
+    });
+  });
+
+  it('returns null for unknown keys', () => {
+    expect(resolveInbound('spaces/x/messages/unknown')).toBeNull();
+  });
+
+  it('expires entries older than INBOUND_TTL_MS on resolve', () => {
+    vi.useFakeTimers();
+    recordInbound({
+      gchatMessageName: 'spaces/x/messages/m1',
+      gchatThreadName: 'spaces/x/threads/t1',
+    });
+    expect(resolveInbound('spaces/x/messages/m1')).not.toBeNull();
+
+    vi.advanceTimersByTime(INBOUND_TTL_MS + 1000);
+    expect(resolveInbound('spaces/x/messages/m1')).toBeNull();
+  });
+
+  it('sweeps expired entries on every insert', () => {
+    vi.useFakeTimers();
+    recordInbound({
+      gchatMessageName: 'spaces/x/messages/m1',
+      gchatThreadName: 'spaces/x/threads/t1',
+    });
+    vi.advanceTimersByTime(INBOUND_TTL_MS + 1000);
+    recordInbound({
+      gchatMessageName: 'spaces/x/messages/m2',
+      gchatThreadName: 'spaces/x/threads/t2',
+    });
+    // m1 should have been swept when m2 was inserted.
+    expect(resolveInbound('spaces/x/messages/m1')).toBeNull();
+    expect(resolveInbound('spaces/x/messages/m2')).not.toBeNull();
+  });
+});

package/src/adapter-google-chat/inbound-cache.ts

@@ -0,0 +1,36 @@
+/**
+ * Google Chat-side wrapper around the shared inbound-message TTL cache.
+ *
+ * Ingestion records each inbound by its `gchatMessageName` (also sent to the
+ * daemon as `externalRef`). When the forwarder later sees `turnStarted` with
+ * that `externalRef`, it resolves the thread anchor by looking up the same
+ * key here.
+ */
+import { createInboundCache } from '../shared/adapters/inbound-cache.js';
+
+export const INBOUND_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+interface GChatInboundValue {
+  gchatThreadName: string;
+}
+
+const cache = createInboundCache<GChatInboundValue>(INBOUND_TTL_MS);
+
+export interface GChatInboundRecord {
+  gchatMessageName: string;
+  gchatThreadName: string;
+}
+
+export function recordInbound(entry: GChatInboundRecord): void {
+  cache.record(entry.gchatMessageName, { gchatThreadName: entry.gchatThreadName });
+}
+
+export function resolveInbound(gchatMessageName: string): GChatInboundRecord | null {
+  const value = cache.resolve(gchatMessageName);
+  return value ? { gchatMessageName, gchatThreadName: value.gchatThreadName } : null;
+}
+
+/** Test hook: drop all cached records. */
+export function _resetInboundCacheForTests(): void {
+  cache.reset();
+}

package/src/adapter-google-chat/state.test.ts

@@ -7,6 +7,7 @@ vi.mock('node:fs/promises', () => ({
     readFile: vi.fn(),
     writeFile: vi.fn(),
     mkdir: vi.fn(),
+    rename: vi.fn(),
   },
 }));
 

package/src/adapter-google-chat/state.ts

@@ -1,3 +1,4 @@
+import crypto from 'node:crypto';
 import fsPromises from 'node:fs/promises';
 import path from 'node:path';
 import { z } from 'zod';
@@ -13,6 +14,7 @@ export const GoogleChatStateSchema = z.object({
         subscriptionId: z.string().optional(),
         expirationDate: z.string().optional(),
         requireMention: z.boolean().optional(),
+        threadsDisabled: z.boolean().optional(),
       })
     )
     .optional(),
@@ -74,7 +76,13 @@ export function updateGoogleChatState(
         const statePath = getGoogleChatStatePath(startDir);
         const dir = path.dirname(statePath);
         await fsPromises.mkdir(dir, { recursive: true });
-        await fsPromises.writeFile(statePath, JSON.stringify(newState, null, 2), 'utf-8');
+        // Atomic write: a plain writeFile truncates then writes, so a
+        // concurrent reader (resolveSpaceForChat runs on every inbound) can
+        // observe an empty file and throw `JSON.parse("")`. rename(2) on the
+        // same filesystem is atomic, so readers always see old or new.
+        const tmpPath = `${statePath}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+        await fsPromises.writeFile(tmpPath, JSON.stringify(newState, null, 2), 'utf-8');
+        await fsPromises.rename(tmpPath, statePath);
         resolve(newState);
       } catch (err) {
         console.error(`Failed to write Google Chat state:`, err);

package/src/adapter-google-chat/subscriptions.ts

@@ -9,11 +9,12 @@ export async function handleAddedToSpace(
   spaceType: string | undefined,
   targetChatId: string | null | undefined,
   mappedChatId: string | null | undefined,
-  config: GoogleChatConfig
+  config: GoogleChatConfig,
+  startDir: string = process.cwd()
 ) {
   if (spaceType !== 'DIRECT_MESSAGE') {
     try {
-      const userAuthClient = await getUserAuthClient(config);
+      const userAuthClient = await getUserAuthClient(config, startDir);
       const tokenResponse = await userAuthClient.getAccessToken();
       const token = tokenResponse.token;
 
@@ -48,7 +49,7 @@ export async function handleAddedToSpace(
                 },
               },
             };
-          });
+          }, startDir);
           console.log(`Created subscription ${subData.name} for space ${externalContextId}`);
         } else {
           const errText = await res.text();
@@ -79,12 +80,13 @@ export async function handleAddedToSpace(
 export async function handleRemovedFromSpace(
   externalContextId: string,
   currentState: GoogleChatState,
-  config: GoogleChatConfig
+  config: GoogleChatConfig,
+  startDir: string = process.cwd()
 ) {
   const subId = currentState.channelChatMap?.[externalContextId]?.subscriptionId;
   if (subId) {
     try {
-      const userAuthClient = await getUserAuthClient(config);
+      const userAuthClient = await getUserAuthClient(config, startDir);
       const tokenResponse = await userAuthClient.getAccessToken();
       const token = tokenResponse.token;
 
@@ -120,5 +122,5 @@ export async function handleRemovedFromSpace(
       }
     }
     return { channelChatMap: map };
-  });
+  }, startDir);
 }

package/src/cli/builtin-policies.ts

@@ -0,0 +1,44 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { resolveCompiledScript } from '../shared/lite.js';
+import { getClawminiDir } from '../shared/workspace.js';
+import { BUILTIN_POLICIES } from '../shared/policies.js';
+
+const HASHBANG = '#!/usr/bin/env node\n';
+
+function sha256(content: string): string {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+export async function installBuiltinPolicies(dirPath = getClawminiDir()): Promise<void> {
+  const policyScriptsDir = path.join(dirPath, 'policy-scripts');
+  await fs.mkdir(policyScriptsDir, { recursive: true });
+
+  for (const name of Object.keys(BUILTIN_POLICIES)) {
+    try {
+      const sourcePath = await resolveCompiledScript(name, import.meta.url);
+      let scriptContent = await fs.readFile(sourcePath, 'utf8');
+      if (!scriptContent.startsWith('#!')) {
+        scriptContent = HASHBANG + scriptContent;
+      }
+
+      const destPath = path.join(policyScriptsDir, `${name}.js`);
+      let existing: string | null = null;
+      try {
+        existing = await fs.readFile(destPath, 'utf8');
+      } catch {
+        // missing — write below
+      }
+      if (existing !== null && sha256(existing) === sha256(scriptContent)) {
+        continue;
+      }
+      await fs.writeFile(destPath, scriptContent, { mode: 0o755 });
+    } catch (err) {
+      console.warn(
+        `Warning: Could not install built-in policy ${name}:`,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+}

package/src/cli/commands/agents.ts

@@ -2,9 +2,13 @@ import { Command } from 'commander';
 import {
   listAgents,
   getAgent,
+  getAgentOverlay,
   writeAgentSettings,
   deleteAgent,
   isValidAgentId,
+  refreshAgentTemplate,
+  refreshAgentSkills,
+  formatPlanActions,
 } from '../../shared/workspace.js';
 import { type Agent } from '../../shared/config.js';
 import { createAgentWithChat } from '../../shared/agent-utils.js';
@@ -57,11 +61,22 @@ agentsCmd
     '-e, --env <env...>',
     'Environment variables in KEY=VALUE format (can be specified multiple times)'
   )
+  .option('--fork', 'Copy the template settings into the agent fully (legacy, no auto-update)')
+  .option('--force', 'Overwrite existing files in the target directory on first install')
   .action(
-    async (id: string, options: { directory?: string; template?: string; env?: string[] }) => {
+    async (
+      id: string,
+      options: {
+        directory?: string;
+        template?: string;
+        env?: string[];
+        fork?: boolean;
+        force?: boolean;
+      }
+    ) => {
       try {
         assertValidAgentId(id);
-        const existing = await getAgent(id);
+        const existing = await getAgentOverlay(id);
         if (existing) {
           throw new Error(`Agent ${id} already exists.`);
         }
@@ -76,7 +91,11 @@ agentsCmd
           agentData.env = { ...(agentData.env || {}), ...env };
         }
 
-        await createAgentWithChat(id, agentData, options.template);
+        const applyOpts = {
+          ...(options.fork ? { fork: true } : {}),
+          ...(options.force ? { force: true } : {}),
+        };
+        await createAgentWithChat(id, agentData, options.template, process.cwd(), applyOpts);
 
         console.log(`Agent ${id} created successfully.`);
       } catch (err) {
@@ -96,7 +115,7 @@ agentsCmd
   .action(async (id: string, options: { directory?: string; env?: string[] }) => {
     try {
       assertValidAgentId(id);
-      const existing = await getAgent(id);
+      const existing = await getAgentOverlay(id);
       if (!existing) {
         throw new Error(`Agent ${id} does not exist.`);
       }
@@ -125,7 +144,7 @@ agentsCmd
   .action(async (id: string) => {
     try {
       assertValidAgentId(id);
-      const existing = await getAgent(id);
+      const existing = await getAgentOverlay(id);
       if (!existing) {
         throw new Error(`Agent ${id} does not exist.`);
       }
@@ -136,3 +155,38 @@ agentsCmd
       handleError('delete agent', err);
     }
   });
+
+agentsCmd
+  .command('refresh <id>')
+  .description("Refresh the agent's tracked template files against the installed clawmini")
+  .option('--accept', 'Overwrite files that have diverged from the recorded SHA')
+  .option('--dry-run', 'Print the per-file plan without writing anything')
+  .action(async (id: string, options: { accept?: boolean; dryRun?: boolean }) => {
+    try {
+      assertValidAgentId(id);
+      const overlay = await getAgentOverlay(id);
+      if (!overlay) {
+        throw new Error(`Agent ${id} does not exist.`);
+      }
+      const refreshOpts = {
+        ...(options.accept === undefined ? {} : { accept: options.accept }),
+        ...(options.dryRun === undefined ? {} : { dryRun: options.dryRun }),
+      };
+      if (overlay.extends) {
+        const plan = await refreshAgentTemplate(id, overlay, process.cwd(), refreshOpts);
+        if (plan) {
+          for (const line of formatPlanActions(plan)) console.log(line);
+        }
+      }
+
+      const resolved = await getAgent(id);
+      if (resolved) {
+        const skillsPlan = await refreshAgentSkills(id, resolved, process.cwd(), refreshOpts);
+        if (skillsPlan) {
+          for (const line of formatPlanActions(skillsPlan)) console.log(line);
+        }
+      }
+    } catch (err) {
+      handleError('refresh agent', err);
+    }
+  });

package/src/cli/commands/down.ts

@@ -1,18 +1,70 @@
 import { Command } from 'commander';
 import { getDaemonClient } from '../client.js';
 import { getSocketPath } from '../../shared/workspace.js';
+import { readSupervisorPid, removeSupervisorPid } from '../supervisor-pid.js';
 import fs from 'node:fs';
 
+function isErrnoCode(err: unknown, code: string): boolean {
+  return err instanceof Error && (err as NodeJS.ErrnoException).code === code;
+}
+
+async function stopSupervisor(pid: number): Promise<void> {
+  process.stdout.write(`Stopping clawmini supervisor (pid ${pid})`);
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (err) {
+    if (isErrnoCode(err, 'ESRCH')) {
+      process.stdout.write('\nSupervisor already exited.\n');
+      return;
+    }
+    throw new Error(
+      `Failed to signal supervisor: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+
+  // Poll until the process is gone or we time out. Must exceed the
+  // supervisor's internal phase-2 timeout (60s for the daemon) so we don't
+  // bail while it's still draining `down` hooks.
+  const TIMEOUT_MS = 90_000;
+  const deadline = Date.now() + TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 200));
+    process.stdout.write('.');
+    try {
+      process.kill(pid, 0);
+    } catch {
+      process.stdout.write('\nSuccessfully shut down clawmini supervisor.\n');
+      return;
+    }
+  }
+  throw new Error(`Supervisor did not exit within ${TIMEOUT_MS / 1000} seconds.`);
+}
+
 export const downCmd = new Command('down')
-  .description('Stop the local clawmini daemon server')
+  .description('Stop the local clawmini supervisor or daemon')
   .action(async () => {
+    const supPid = readSupervisorPid();
+    if (supPid) {
+      try {
+        await stopSupervisor(supPid);
+        return;
+      } catch (err) {
+        console.error('\n', err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    }
+
+    // No live supervisor — drop any stale pid file so future commands
+    // aren't confused by it.
+    removeSupervisorPid();
+
     try {
       const client = await getDaemonClient({ autoStart: false });
       process.stdout.write('Shutting down clawmini daemon...');
       await client.shutdown.mutate();
 
       const socketPath = getSocketPath();
-      // Wait for the socket file to be removed by the daemon's exit handler
       while (fs.existsSync(socketPath)) {
         await new Promise((resolve) => setTimeout(resolve, 200));
         process.stdout.write('.');

package/src/cli/commands/environments.ts

@@ -8,9 +8,15 @@ environmentsCmd
   .command('enable <name>')
   .description('Enable an environment for a path in the workspace')
   .option('-p, --path <subpath>', 'Path to apply the environment to', './')
-  .action(async (name: string, options: { path: string }) => {
+  .option('--fork', 'Clone the built-in template directory instead of writing a thin overlay')
+  .action(async (name: string, options: { path: string; fork?: boolean }) => {
     try {
-      await enableEnvironment(name, options.path);
+      await enableEnvironment(
+        name,
+        options.path,
+        process.cwd(),
+        options.fork ? { fork: true } : {}
+      );
     } catch (err) {
       handleError('enable environment', err);
     }

package/src/cli/commands/init.ts

@@ -1,11 +1,29 @@
 import { Command } from 'commander';
 import fs from 'node:fs';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { isValidAgentId, enableEnvironment } from '../../shared/workspace.js';
 import { setDefaultChatId } from '../../shared/chats.js';
 import { type Agent } from '../../shared/config.js';
 import { createAgentWithChat } from '../../shared/agent-utils.js';
 import { handleError } from '../utils.js';
+import { installBuiltinPolicies } from '../builtin-policies.js';
+
+function readBackupGitignoreTemplate(): string | null {
+  let currentDir = path.dirname(fileURLToPath(import.meta.url));
+  while (
+    currentDir !== path.parse(currentDir).root &&
+    !fs.existsSync(path.join(currentDir, 'package.json'))
+  ) {
+    currentDir = path.dirname(currentDir);
+  }
+  const templatePath = path.join(currentDir, 'docs', 'backups', 'clawmini.gitignore');
+  try {
+    return fs.readFileSync(templatePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
 
 export const initCmd = new Command('init')
   .description('Initialize a new .clawmini settings folder')
@@ -47,6 +65,19 @@ export const initCmd = new Command('init')
     fs.writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2));
     console.log('Initialized .clawmini/settings.json');
 
+    const gitignoreTemplate = readBackupGitignoreTemplate();
+    if (gitignoreTemplate) {
+      const gitignorePath = path.join(dirPath, '.gitignore');
+      if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, gitignoreTemplate);
+        console.log('Initialized .clawmini/.gitignore');
+      }
+    } else {
+      console.warn('Warning: backup .gitignore template not found; skipping .clawmini/.gitignore');
+    }
+
+    await installBuiltinPolicies(dirPath);
+
     if (options.agent) {
       try {
         const agentId = options.agent;

package/src/cli/commands/logs.ts

@@ -0,0 +1,116 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { getClawminiDir } from '../../shared/workspace.js';
+
+const SERVICE_ALIASES: Record<string, string> = {
+  daemon: 'daemon',
+  web: 'web',
+  discord: 'adapter-discord',
+  'adapter-discord': 'adapter-discord',
+  'google-chat': 'adapter-google-chat',
+  'adapter-google-chat': 'adapter-google-chat',
+  supervisor: 'supervisor',
+};
+
+function displayNameFor(logBase: string): string {
+  if (logBase.startsWith('adapter-')) return logBase.slice('adapter-'.length);
+  return logBase;
+}
+
+function tailString(content: string, n: number): string[] {
+  const lines = content.split('\n');
+  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+  return lines.slice(-n);
+}
+
+interface LogsOptions {
+  follow?: boolean;
+  service?: string;
+  lines?: string;
+}
+
+export const logsCmd = new Command('logs')
+  .description('View logs from clawmini services (daemon, web, adapters)')
+  .option('-f, --follow', 'Follow the logs as new lines are written')
+  .option(
+    '-s, --service <name>',
+    'Restrict to one service: daemon, web, discord, google-chat, supervisor'
+  )
+  .option('-n, --lines <count>', 'Number of lines to show from the tail of each file', '50')
+  .action(async (options: LogsOptions) => {
+    const logDir = path.join(getClawminiDir(), 'logs');
+    if (!fs.existsSync(logDir)) {
+      console.error(`No log directory at ${logDir}. Start the supervisor with 'clawmini serve'.`);
+      process.exit(1);
+    }
+
+    let targets: string[];
+    if (options.service) {
+      const resolved = SERVICE_ALIASES[options.service];
+      if (!resolved) {
+        console.error(
+          `Unknown service '${options.service}'. Valid: ${Object.keys(SERVICE_ALIASES).join(', ')}`
+        );
+        process.exit(1);
+      }
+      targets = [`${resolved}.log`];
+    } else {
+      targets = fs.readdirSync(logDir).filter((f) => f.endsWith('.log'));
+    }
+
+    const linesCount = Math.max(0, parseInt(options.lines ?? '50', 10) || 50);
+
+    for (const file of targets) {
+      const full = path.join(logDir, file);
+      if (!fs.existsSync(full)) continue;
+      const prefix = `[${displayNameFor(file.replace(/\.log$/, ''))}] `;
+      const content = fs.readFileSync(full, 'utf-8');
+      for (const line of tailString(content, linesCount)) {
+        process.stdout.write(prefix + line + '\n');
+      }
+    }
+
+    if (!options.follow) return;
+
+    const watched: Array<{ file: string; full: string; prefix: string; position: number }> = [];
+    for (const file of targets) {
+      const full = path.join(logDir, file);
+      const prefix = `[${displayNameFor(file.replace(/\.log$/, ''))}] `;
+      const position = fs.existsSync(full) ? fs.statSync(full).size : 0;
+      watched.push({ file, full, prefix, position });
+      fs.watchFile(full, { interval: 500 }, (curr) => {
+        const entry = watched.find((w) => w.full === full);
+        if (!entry) return;
+        if (curr.size < entry.position) {
+          entry.position = 0;
+        }
+        if (curr.size > entry.position) {
+          const fd = fs.openSync(full, 'r');
+          const buf = Buffer.alloc(curr.size - entry.position);
+          fs.readSync(fd, buf, 0, buf.length, entry.position);
+          fs.closeSync(fd);
+          entry.position = curr.size;
+
+          const text = buf.toString();
+          const lines = text.split('\n');
+          if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+          for (const line of lines) {
+            process.stdout.write(entry.prefix + line + '\n');
+          }
+        }
+      });
+    }
+
+    const stop = () => {
+      for (const entry of watched) fs.unwatchFile(entry.full);
+      process.exit(0);
+    };
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+
+    await new Promise<void>(() => {
+      /* intentionally unresolved; signals drive termination */
+    });
+  });

package/src/cli/commands/policies.ts

@@ -3,10 +3,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { handleError } from '../utils.js';
 import { resolveCompiledScript } from '../../shared/lite.js';
-import type { PolicyConfig } from '../../shared/policies.js';
+import { BUILTIN_POLICIES, type PolicyConfig } from '../../shared/policies.js';
 import { getClawminiDir } from '../../shared/workspace.js';
 
-const SUPPORTED_POLICIES = ['propose-policy'];
+const SUPPORTED_POLICIES = ['manage-policies'];
 
 export const policiesCmd = new Command('policies').description('Manage sandbox policies');
 
@@ -44,10 +44,12 @@ policiesCmd
       policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
     }
 
+    const builtin = BUILTIN_POLICIES[name];
     policies.policies[name] = {
-      description: 'Propose a new policy to create',
+      description: builtin?.description ?? `Built-in policy ${name}`,
       command: `./.clawmini/policy-scripts/${name}.js`,
-      allowHelp: true,
+      allowHelp: builtin?.allowHelp ?? true,
+      ...(builtin?.autoApprove !== undefined ? { autoApprove: builtin.autoApprove } : {}),
     };
 
     fs.writeFileSync(policiesPath, JSON.stringify(policies, null, 2));