clawmini 0.0.1 → 0.0.3

package/src/daemon/api/user-router.ts

@@ -0,0 +1,221 @@
+import { z } from 'zod';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { TRPCError } from '@trpc/server';
+import { pathIsInsideDir } from '../../shared/utils/fs.js';
+import { on } from 'node:events';
+import { daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED, DAEMON_EVENT_TYPING } from '../events.js';
+import { getSettingsPath, readChatSettings, getWorkspaceRoot } from '../../shared/workspace.js';
+import { CronJobSchema } from '../../shared/config.js';
+import { handleUserMessage } from '../message.js';
+import { getDefaultChatId, getMessages as fetchMessages } from '../chats.js';
+import { runCommand } from '../utils/spawn.js';
+import { apiProcedure, publicProcedure, router } from './trpc.js';
+import {
+  getUniquePath,
+  resolveAgentDir,
+  getAgentFilesDir,
+  validateAttachments,
+  listCronJobsShared,
+  addCronJobShared,
+  deleteCronJobShared,
+} from './router-utils.js';
+
+export const sendMessage = apiProcedure
+  .input(
+    z.object({
+      type: z.literal('send-message'),
+      client: z.literal('cli'),
+      data: z.object({
+        message: z.string(),
+        chatId: z.string().optional(),
+        sessionId: z.string().optional(),
+        agentId: z.string().optional(),
+        noWait: z.boolean().optional(),
+        files: z.array(z.string()).optional(),
+        adapter: z.string().optional(),
+      }),
+    })
+  )
+  .mutation(async ({ input }) => {
+    let message = input.data.message;
+    const chatId = input.data.chatId ?? (await getDefaultChatId());
+    const noWait = input.data.noWait ?? false;
+    const sessionId = input.data.sessionId;
+    const agentId = input.data.agentId;
+    const settingsPath = getSettingsPath();
+
+    let settings;
+    try {
+      const settingsStr = await fs.readFile(settingsPath, 'utf8');
+      settings = JSON.parse(settingsStr);
+    } catch (err) {
+      throw new Error(`Failed to read settings from ${settingsPath}: ${err}`, { cause: err });
+    }
+
+    const files = input.data.files;
+    if (files && files.length > 0) {
+      const workspaceRoot = getWorkspaceRoot(process.cwd());
+      const chatSettings = (await readChatSettings(chatId)) ?? {};
+      const targetAgentId = agentId ?? chatSettings.defaultAgent ?? 'default';
+      const agentDir = await resolveAgentDir(targetAgentId, workspaceRoot);
+      const absoluteFilesDir = await getAgentFilesDir(agentId, chatId, settings, workspaceRoot);
+
+      const adapterNamespace = input.data.adapter || 'cli';
+      const targetDir = path.join(absoluteFilesDir, adapterNamespace);
+
+      if (!pathIsInsideDir(targetDir, workspaceRoot, { allowSameDir: true })) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'Target directory must be within the workspace.',
+        });
+      }
+
+      await validateAttachments(files);
+
+      await fs.mkdir(targetDir, { recursive: true });
+
+      const finalPaths: string[] = [];
+      for (const file of files) {
+        const fileName = path.basename(file);
+        const targetPath = await getUniquePath(path.join(targetDir, fileName));
+
+        try {
+          await fs.rename(file, targetPath);
+        } catch {
+          await fs.copyFile(file, targetPath);
+          await fs.unlink(file);
+        }
+
+        finalPaths.push(path.relative(agentDir, targetPath));
+      }
+
+      const fileList = `Attached files:\n${finalPaths.map((p) => `- ${p}`).join('\n')}`;
+      message = message ? `${message}\n\n${fileList}` : fileList;
+    }
+
+    await handleUserMessage(
+      chatId,
+      message,
+      settings,
+      undefined,
+      noWait,
+      (args) => runCommand({ ...args, logToTerminal: true }),
+      sessionId,
+      agentId
+    );
+
+    return { success: true };
+  });
+
+export const getMessages = apiProcedure
+  .input(z.object({ chatId: z.string().optional(), limit: z.number().optional() }))
+  .query(async ({ input }) => {
+    const chatId = input.chatId ?? (await getDefaultChatId());
+    return fetchMessages(chatId, input.limit);
+  });
+
+export const waitForMessages = apiProcedure
+  .input(
+    z.object({
+      chatId: z.string().optional(),
+      lastMessageId: z.string().optional(),
+    })
+  )
+  .subscription(async function* ({ input, signal }) {
+    const chatId = input.chatId ?? (await getDefaultChatId());
+
+    // 1. Check if there are already new messages
+    if (input.lastMessageId) {
+      const messages = await fetchMessages(chatId);
+      const lastIndex = messages.findIndex((m) => m.id === input.lastMessageId);
+      if (lastIndex !== -1 && lastIndex < messages.length - 1) {
+        yield messages.slice(lastIndex + 1);
+      }
+    }
+
+    // 2. Listen for new messages
+    try {
+      for await (const [event] of on(daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED, { signal })) {
+        if (event.chatId === chatId) {
+          yield [event.message];
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name === 'AbortError') {
+        return;
+      }
+      throw err;
+    }
+  });
+
+export const waitForTyping = apiProcedure
+  .input(
+    z.object({
+      chatId: z.string().optional(),
+    })
+  )
+  .subscription(async function* ({ input, signal }) {
+    const chatId = input.chatId ?? (await getDefaultChatId());
+
+    try {
+      for await (const [event] of on(daemonEvents, DAEMON_EVENT_TYPING, { signal })) {
+        if (event.chatId === chatId) {
+          yield event;
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name === 'AbortError') {
+        return;
+      }
+      throw err;
+    }
+  });
+
+export const ping = publicProcedure.query(() => {
+  return { status: 'ok' };
+});
+
+export const shutdown = publicProcedure.mutation(() => {
+  // Schedule a shutdown shortly after the response is sent
+  setTimeout(() => {
+    console.log('Shutting down daemon...');
+    process.kill(process.pid, 'SIGTERM');
+  }, 100);
+  return { success: true };
+});
+
+export const userListCronJobs = apiProcedure
+  .input(z.object({ chatId: z.string().optional() }))
+  .query(async ({ input }) => {
+    const chatId = input.chatId ?? (await getDefaultChatId());
+    return listCronJobsShared(chatId);
+  });
+
+export const userAddCronJob = apiProcedure
+  .input(z.object({ chatId: z.string().optional(), job: CronJobSchema }))
+  .mutation(async ({ input }) => {
+    const chatId = input.chatId ?? (await getDefaultChatId());
+    return addCronJobShared(chatId, input.job);
+  });
+
+export const userDeleteCronJob = apiProcedure
+  .input(z.object({ chatId: z.string().optional(), id: z.string() }))
+  .mutation(async ({ input }) => {
+    const chatId = input.chatId ?? (await getDefaultChatId());
+    return deleteCronJobShared(chatId, input.id);
+  });
+
+export const userRouter = router({
+  sendMessage,
+  getMessages,
+  waitForMessages,
+  waitForTyping,
+  ping,
+  shutdown,
+  listCronJobs: userListCronJobs,
+  addCronJob: userAddCronJob,
+  deleteCronJob: userDeleteCronJob,
+});
+
+export type UserRouter = typeof userRouter;

package/src/daemon/index.ts

@@ -3,7 +3,7 @@ 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 { userRouter, agentRouter } from './api/index.js';
 import {
   getSocketPath,
   getClawminiDir,
@@ -114,7 +114,7 @@ export async function initDaemon() {
   });
 
   const handler = createHTTPHandler({
-    router: appRouter,
+    router: userRouter,
     createContext: ({ req, res }) => ({ req, res, isApiServer: false }),
   });
 
@@ -153,7 +153,7 @@ export async function initDaemon() {
   let apiServer: http.Server | undefined;
   if (apiCtx) {
     const apiHandler = createHTTPHandler({
-      router: appRouter,
+      router: agentRouter,
       createContext: ({ req, res }) => {
         let tokenPayload = null;
         const authHeader = req.headers.authorization;

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

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { executeDirectMessage } from './message.js';
-import { getQueue } from './queue.js';
+import { getMessageQueue } from './queue.js';
 import type { RouterState } from './routers/types.js';
 
 vi.mock('./chats.js', () => ({
@@ -25,7 +25,7 @@ describe('Interruption flow in message handler', () => {
   });
 
   it('stops execution and clears queue when action is stop', async () => {
-    const queue = getQueue('/test-interrupt-stop');
+    const queue = getMessageQueue('/test-interrupt-stop');
     const abortSpy = vi.spyOn(queue, 'abortCurrent');
     const clearSpy = vi.spyOn(queue, 'clear');
 
@@ -48,7 +48,7 @@ describe('Interruption flow in message handler', () => {
   });
 
   it('interrupts execution and batches pending tasks when action is interrupt', async () => {
-    const queue = getQueue('/test-interrupt-batch');
+    const queue = getMessageQueue('/test-interrupt-batch');
     const abortSpy = vi.spyOn(queue, 'abortCurrent');
 
     // Block the queue with a running task so subsequent ones stay pending
@@ -60,14 +60,20 @@ describe('Interruption flow in message handler', () => {
 
     // Enqueue some dummy tasks with payloads
     queue
-      .enqueue(async () => {
-        await new Promise((r) => setTimeout(r, 100));
-      }, 'pending 1')
+      .enqueue(
+        async () => {
+          await new Promise((r) => setTimeout(r, 100));
+        },
+        { text: 'pending 1', sessionId: 'test-session' }
+      )
       .catch(() => {});
     queue
-      .enqueue(async () => {
-        await new Promise((r) => setTimeout(r, 100));
-      }, 'pending 2')
+      .enqueue(
+        async () => {
+          await new Promise((r) => setTimeout(r, 100));
+        },
+        { text: 'pending 2', sessionId: 'test-session' }
+      )
       .catch(() => {});
 
     const state: RouterState = {
@@ -75,6 +81,7 @@ describe('Interruption flow in message handler', () => {
       messageId: 'mock-msg-id',
       chatId: 'chat1',
       action: 'interrupt',
+      sessionId: 'test-session',
     };
 
     const runCommand = vi.fn().mockResolvedValue({ stdout: 'done', stderr: '', exitCode: 0 });
@@ -102,7 +109,7 @@ describe('Interruption flow in message handler', () => {
   });
 
   it('returns early when message is empty and no action is specified', async () => {
-    const queue = getQueue('/test-interrupt-empty');
+    const queue = getMessageQueue('/test-interrupt-empty');
     const state: RouterState = {
       message: '   ',
       messageId: 'mock-msg-id',

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

@@ -17,7 +17,7 @@ vi.mock('../shared/chats.js', () => ({
 }));
 
 vi.mock('./queue.js', () => ({
-  getQueue: vi.fn().mockReturnValue({
+  getMessageQueue: vi.fn().mockReturnValue({
     enqueue: (fn: any) => fn(),
   }),
 }));