clawmini 0.0.1

package/src/daemon/cron.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { CronManager } from './cron.js';
+
+describe('CronManager', () => {
+  it('throws on invalid date in "at" schedule', () => {
+    const cronManager = new CronManager();
+    expect(() => {
+      cronManager.scheduleJob('chat1', {
+        id: 'job1',
+        createdAt: new Date().toISOString(),
+        message: 'hello',
+        schedule: { at: 'invalid-date' },
+      });
+    }).toThrow("Invalid date format for 'at' schedule: invalid-date");
+  });
+
+  it('correctly schedules an interval "at" schedule', () => {
+    const cronManager = new CronManager();
+    expect(() => {
+      cronManager.scheduleJob('chat2', {
+        id: 'job2',
+        createdAt: new Date().toISOString(),
+        message: 'hello',
+        schedule: { at: '2m' },
+      });
+    }).not.toThrow();
+  });
+});

package/src/daemon/cron.ts

@@ -0,0 +1,159 @@
+// @ts-expect-error - node-schedule types are missing
+import schedule from 'node-schedule';
+import { listChats } from '../shared/chats.js';
+import { readChatSettings, writeChatSettings } from '../shared/workspace.js';
+import { executeDirectMessage, getInitialRouterState } from './message.js';
+import type { CronJob, Settings } from '../shared/config.js';
+import fs from 'node:fs/promises';
+import { getSettingsPath } from '../shared/workspace.js';
+import { applyEnvOverrides } from '../shared/utils/env.js';
+import { runCommand } from './utils/spawn.js';
+
+export class CronManager {
+  private jobs = new Map<string, schedule.Job>();
+
+  private getJobKey(chatId: string, jobId: string) {
+    return `${chatId}::${jobId}`;
+  }
+
+  async init() {
+    const chats = await listChats();
+    for (const chatId of chats) {
+      const settings = await readChatSettings(chatId);
+      if (settings?.jobs) {
+        for (const job of settings.jobs) {
+          try {
+            this.scheduleJob(chatId, job);
+          } catch (err) {
+            console.error(
+              `Failed to initialize job ${job.id} for chat ${chatId}:`,
+              err instanceof Error ? err.message : err
+            );
+          }
+        }
+      }
+    }
+  }
+
+  scheduleJob(chatId: string, job: CronJob) {
+    this.unscheduleJob(chatId, job.id);
+
+    let rule: string | Date;
+    let isOneOff = false;
+
+    if ('cron' in job.schedule) {
+      rule = (job.schedule as { cron: string }).cron;
+    } else if ('every' in job.schedule) {
+      const everyStr = (job.schedule as { every: string }).every;
+      const match = everyStr.match(/^(\d+)\s*(m|min|minutes?|h|hours?|d|days?)$/i);
+      if (match) {
+        const val = parseInt(match[1]!, 10);
+        const unit = match[2]!.toLowerCase();
+        if (unit.startsWith('m')) {
+          rule = `*/${val} * * * *`;
+        } else if (unit.startsWith('h')) {
+          rule = `0 */${val} * * *`;
+        } else if (unit.startsWith('d')) {
+          rule = `0 0 */${val} * *`;
+        } else {
+          rule = everyStr;
+        }
+      } else {
+        rule = everyStr;
+      }
+    } else if ('at' in job.schedule) {
+      const atStr = (job.schedule as { at: string }).at;
+      const match = atStr.match(/^(\d+)\s*(m|min|minutes?|h|hours?|d|days?|s|sec|seconds?)$/i);
+      if (match) {
+        const val = parseInt(match[1]!, 10);
+        const unit = match[2]!.toLowerCase();
+        let ms = 0;
+        if (unit.startsWith('s')) ms = val * 1000;
+        else if (unit.startsWith('m')) ms = val * 60 * 1000;
+        else if (unit.startsWith('h')) ms = val * 60 * 60 * 1000;
+        else if (unit.startsWith('d')) ms = val * 24 * 60 * 60 * 1000;
+        rule = new Date(Date.now() + ms);
+      } else {
+        rule = new Date(atStr);
+        if (isNaN(rule.getTime())) {
+          throw new Error(`Invalid date format for 'at' schedule: ${atStr}`);
+        }
+      }
+      isOneOff = true;
+    } else {
+      console.warn(`Unknown schedule format for job ${job.id}`);
+      return;
+    }
+
+    try {
+      const scheduledJob = schedule.scheduleJob(rule, async () => {
+        await this.executeJob(chatId, job, isOneOff);
+      });
+      if (scheduledJob) {
+        this.jobs.set(this.getJobKey(chatId, job.id), scheduledJob);
+      }
+    } catch (err) {
+      console.error(`Failed to schedule job ${job.id} for chat ${chatId}:`, err);
+    }
+  }
+
+  unscheduleJob(chatId: string, jobId: string) {
+    const key = this.getJobKey(chatId, jobId);
+    const job = this.jobs.get(key);
+    if (job) {
+      job.cancel();
+      this.jobs.delete(key);
+    }
+  }
+
+  private async executeJob(chatId: string, job: CronJob, isOneOff: boolean) {
+    try {
+      const settingsPath = getSettingsPath();
+      let globalSettings: Settings | undefined;
+      try {
+        const settingsStr = await fs.readFile(settingsPath, 'utf8');
+        globalSettings = JSON.parse(settingsStr) as Settings;
+      } catch {
+        globalSettings = undefined;
+      }
+
+      const overrideSessionId = job.session?.type === 'new' ? crypto.randomUUID() : undefined;
+      const routerState = await getInitialRouterState(
+        chatId,
+        job.message,
+        process.cwd(),
+        job.agentId,
+        overrideSessionId
+      );
+
+      if (job.env !== undefined) {
+        routerState.env = routerState.env || {};
+        applyEnvOverrides(routerState.env, job.env);
+      }
+      if (job.reply !== undefined) routerState.reply = job.reply;
+
+      await executeDirectMessage(
+        chatId,
+        routerState,
+        globalSettings,
+        process.cwd(),
+        runCommand,
+        false,
+        job.message
+      );
+
+      if (isOneOff) {
+        const chatSettings = await readChatSettings(chatId);
+        if (chatSettings && chatSettings.jobs) {
+          chatSettings.jobs = chatSettings.jobs.filter((j) => j.id !== job.id);
+          await writeChatSettings(chatId, chatSettings);
+        }
+        this.unscheduleJob(chatId, job.id);
+      }
+    } catch (err) {
+      console.error(`Error executing cron job ${job.id} for chat ${chatId}:`, err);
+    }
+  }
+}
+
+export const cronManager = new CronManager();

package/src/daemon/events.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from 'node:events';
+import type { ChatMessage } from '../shared/chats.js';
+
+export const daemonEvents = new EventEmitter();
+
+export const DAEMON_EVENT_MESSAGE_APPENDED = 'message-appended';
+export const DAEMON_EVENT_TYPING = 'typing';
+
+export function emitMessageAppended(chatId: string, message: ChatMessage) {
+  daemonEvents.emit(DAEMON_EVENT_MESSAGE_APPENDED, { chatId, message });
+}
+
+export function emitTyping(chatId: string) {
+  daemonEvents.emit(DAEMON_EVENT_TYPING, { chatId });
+}

package/src/daemon/index.ts

@@ -0,0 +1,212 @@
+import http from 'node:http';
+import net from 'node:net';
+import fs from 'node:fs';
+import { execSync } from 'node:child_process';
+import { createHTTPHandler } from '@trpc/server/adapters/standalone';
+import { appRouter } from './router.js';
+import {
+  getSocketPath,
+  getClawminiDir,
+  getSettingsPath,
+  readSettings,
+  readEnvironment,
+  getEnvironmentPath,
+  getWorkspaceRoot,
+} from '../shared/workspace.js';
+import { cronManager } from './cron.js';
+import { SettingsSchema } from '../shared/config.js';
+import { validateToken, getApiContext } from './auth.js';
+import path from 'node:path';
+import { exportLiteToEnvironment } from '../shared/lite.js';
+
+export async function initDaemon() {
+  const socketPath = getSocketPath();
+  const clawminiDir = getClawminiDir();
+
+  // Ensure the .clawmini directory exists
+  if (!fs.existsSync(clawminiDir)) {
+    throw new Error(`${clawminiDir} does not exist`);
+  }
+
+  // Read settings to check if API is enabled
+  const settingsPath = getSettingsPath();
+  let apiCtx: ReturnType<typeof getApiContext> = null;
+
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const settingsStr = fs.readFileSync(settingsPath, 'utf8');
+      const settings = JSON.parse(settingsStr);
+      const parsed = SettingsSchema.safeParse(settings);
+      if (parsed.success) {
+        apiCtx = getApiContext(parsed.data);
+      }
+    } catch (err) {
+      console.warn(`Failed to read or parse settings from ${settingsPath}:`, err);
+    }
+  }
+
+  const runHooks = async (hookType: 'up' | 'down') => {
+    try {
+      const currentSettings = await readSettings();
+      const workspaceRoot = getWorkspaceRoot(process.cwd());
+      if (!currentSettings?.environments) return;
+      for (const [envPath, envName] of Object.entries(currentSettings.environments)) {
+        try {
+          const envConfig = await readEnvironment(envName);
+          const envDir = getEnvironmentPath(envName);
+          const affectedDir = path.resolve(workspaceRoot, envPath);
+
+          // Try to export clawmini-lite to the environment directory
+          if (hookType === 'up' && envConfig) {
+            await exportLiteToEnvironment(envName, envConfig, affectedDir);
+          }
+
+          const command = envConfig?.[hookType];
+          if (command) {
+            console.log(`Executing '${hookType}' hook for environment '${envName}': ${command}`);
+            execSync(command, {
+              cwd: affectedDir,
+              stdio: 'inherit',
+              env: { ...process.env, ENV_DIR: envDir },
+              timeout: hookType === 'down' ? 10000 : undefined,
+            });
+          }
+        } catch (err) {
+          console.error(`Failed to execute '${hookType}' hook for environment '${envName}':`, err);
+          if (hookType === 'up') throw err;
+        }
+      }
+    } catch (err) {
+      console.error(`Failed to run '${hookType}' hooks:`, err);
+      if (hookType === 'up') throw err;
+    }
+  };
+
+  // Ensure the old socket file is removed, but first check if another daemon is actively listening
+  if (fs.existsSync(socketPath)) {
+    const isSocketInUse = await new Promise<boolean>((resolve) => {
+      const client = net.createConnection({ path: socketPath });
+      client.on('connect', () => {
+        client.destroy();
+        resolve(true);
+      });
+      client.on('error', () => {
+        resolve(false);
+      });
+    });
+
+    if (isSocketInUse) {
+      console.log('Daemon is already running (socket is active). Exiting.');
+      process.exit(0);
+    }
+
+    try {
+      fs.unlinkSync(socketPath);
+    } catch {
+      // Ignore
+    }
+  }
+
+  let isReady = false;
+  let readyPromiseResolve: () => void;
+  const readyPromise = new Promise<void>((resolve) => {
+    readyPromiseResolve = resolve;
+  });
+
+  const handler = createHTTPHandler({
+    router: appRouter,
+    createContext: ({ req, res }) => ({ req, res, isApiServer: false }),
+  });
+
+  const server = http.createServer(async (req, res) => {
+    if (!isReady) {
+      await readyPromise;
+    }
+    // Only accept POST requests on /trpc/ path if needed, but since we are running over Unix socket, we map directly
+    handler(req, res);
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.on('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE') {
+        console.log('Daemon is already running (socket bind failed). Exiting.');
+        process.exit(0);
+      }
+      reject(err);
+    });
+    server.listen(socketPath, () => {
+      console.log(`Daemon initialized and listening on ${socketPath}`);
+      resolve();
+    });
+  });
+
+  await runHooks('up');
+
+  isReady = true;
+  readyPromiseResolve!();
+
+  // Initialize cron jobs
+  cronManager.init().catch((err) => {
+    console.error('Failed to initialize cron manager:', err);
+  });
+
+  let apiServer: http.Server | undefined;
+  if (apiCtx) {
+    const apiHandler = createHTTPHandler({
+      router: appRouter,
+      createContext: ({ req, res }) => {
+        let tokenPayload = null;
+        const authHeader = req.headers.authorization;
+        if (authHeader && authHeader.startsWith('Bearer ')) {
+          const token = authHeader.substring(7);
+          tokenPayload = validateToken(token);
+        }
+        return { req, res, isApiServer: true, tokenPayload };
+      },
+    });
+
+    apiServer = http.createServer((req, res) => {
+      apiHandler(req, res);
+    });
+
+    const host = apiCtx.host;
+    const port = apiCtx.port;
+    apiServer.listen(port, host, () => {
+      console.log(`Daemon HTTP API initialized and listening on http://${host}:${port}`);
+    });
+  }
+
+  let isShuttingDown = false;
+  const shutdown = async () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    console.log('Daemon shutting down...');
+
+    await runHooks('down');
+
+    server.close();
+    if (apiServer) apiServer.close();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  process.on('exit', () => {
+    if (fs.existsSync(socketPath)) {
+      try {
+        fs.unlinkSync(socketPath);
+      } catch {
+        // Ignore errors during exit cleanup
+      }
+    }
+  });
+}
+
+// Only auto-initialize if run directly
+if (process.argv[1] === new URL(import.meta.url).pathname) {
+  initDaemon().catch((err) => {
+    console.error('Daemon initialization failed:', err);
+    process.exit(1);
+  });
+}

package/src/daemon/message-agent.test.ts

@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleUserMessage } from './message.js';
+import * as workspace from '../shared/workspace.js';
+import { spawn } from 'node:child_process';
+import { runCommandCallback, createAutoFinishMockSpawn } from './message-test-utils.js';
+
+vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
+vi.mock('../shared/chats.js', () => ({ appendMessage: vi.fn().mockResolvedValue(undefined) }));
+vi.mock('./routers.js', () => ({
+  executeRouterPipeline: vi.fn().mockImplementation((state) => Promise.resolve(state)),
+}));
+vi.mock('../shared/workspace.js', () => ({
+  readChatSettings: vi.fn().mockResolvedValue(null),
+  writeChatSettings: vi.fn().mockResolvedValue(undefined),
+  readAgentSessionSettings: vi.fn().mockResolvedValue(null),
+  writeAgentSessionSettings: vi.fn().mockResolvedValue(undefined),
+  getAgent: vi.fn().mockResolvedValue(null),
+  getWorkspaceRoot: vi.fn().mockImplementation((cwd) => cwd),
+  getActiveEnvironmentName: vi.fn().mockResolvedValue(null),
+  getActiveEnvironmentInfo: vi.fn().mockResolvedValue(null),
+  getEnvironmentPath: vi.fn().mockReturnValue(''),
+  readEnvironment: vi.fn().mockResolvedValue(null),
+}));
+
+describe('Agent Configuration & Execution CWD', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('merges custom agent settings over defaultAgent', async () => {
+    const mockSpawn = createAutoFinishMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    vi.mocked(workspace.readChatSettings).mockResolvedValue({ defaultAgent: 'custom-agent' });
+    vi.mocked(workspace.readAgentSessionSettings).mockResolvedValue(null);
+    vi.mocked(workspace.getAgent).mockResolvedValue({
+      commands: {
+        new: 'echo custom',
+      },
+      env: {
+        CUSTOM_VAR: 'yes',
+      },
+    });
+
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo main', append: 'echo append' },
+        env: { DEFAULT_VAR: 'yes' },
+      },
+    };
+
+    await handleUserMessage(
+      'chat-custom',
+      'hello',
+      settings as any,
+      '/dir',
+      false,
+      runCommandCallback
+    );
+
+    expect(workspace.getAgent).toHaveBeenCalledWith('custom-agent', '/dir');
+    expect(mockSpawn).toHaveBeenCalledWith(
+      'echo custom',
+      expect.objectContaining({
+        env: expect.objectContaining({
+          DEFAULT_VAR: 'yes',
+          CUSTOM_VAR: 'yes',
+        }),
+      })
+    );
+  });
+
+  it('resolves cwd based on custom agent name if directory is not provided', async () => {
+    const mockSpawn = createAutoFinishMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    vi.mocked(workspace.readChatSettings).mockResolvedValue({ defaultAgent: 'some-agent' });
+    vi.mocked(workspace.getAgent).mockResolvedValue({
+      commands: { new: 'echo agent-dir' },
+    });
+    vi.mocked(workspace.getWorkspaceRoot).mockReturnValue('/base/workspace');
+
+    const settings = { defaultAgent: { commands: { new: 'echo main' } } };
+
+    await handleUserMessage(
+      'chat-dir-1',
+      'hi',
+      settings as any,
+      '/base/workspace',
+      false,
+      runCommandCallback
+    );
+
+    expect(mockSpawn).toHaveBeenCalledWith(
+      'echo agent-dir',
+      expect.objectContaining({
+        cwd: '/base/workspace/some-agent',
+      })
+    );
+  });
+
+  it('resolves cwd based on agent directory property if provided', async () => {
+    const mockSpawn = createAutoFinishMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    vi.mocked(workspace.readChatSettings).mockResolvedValue({ defaultAgent: 'custom-dir-agent' });
+    vi.mocked(workspace.getAgent).mockResolvedValue({
+      directory: 'src/custom-path',
+      commands: { new: 'echo my-dir' },
+    });
+    vi.mocked(workspace.getWorkspaceRoot).mockReturnValue('/base/workspace');
+
+    const settings = { defaultAgent: { commands: { new: 'echo main' } } };
+
+    await handleUserMessage(
+      'chat-dir-2',
+      'hi',
+      settings as any,
+      '/base/workspace',
+      false,
+      runCommandCallback
+    );
+
+    expect(mockSpawn).toHaveBeenCalledWith(
+      'echo my-dir',
+      expect.objectContaining({
+        cwd: '/base/workspace/src/custom-path',
+      })
+    );
+  });
+});