clawmini 0.0.3 → 0.0.5

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

@@ -0,0 +1,124 @@
+import { google } from 'googleapis';
+import type { GoogleChatConfig } from './config.js';
+import { getAuthClient, getUserAuthClient } from './auth.js';
+import { updateGoogleChatState, type GoogleChatState } from './state.js';
+
+export async function handleAddedToSpace(
+  spaceName: string,
+  externalContextId: string,
+  spaceType: string | undefined,
+  targetChatId: string | null | undefined,
+  mappedChatId: string | null | undefined,
+  config: GoogleChatConfig
+) {
+  if (spaceType !== 'DIRECT_MESSAGE') {
+    try {
+      const userAuthClient = await getUserAuthClient(config);
+      const tokenResponse = await userAuthClient.getAccessToken();
+      const token = tokenResponse.token;
+
+      if (token) {
+        const res = await fetch('https://workspaceevents.googleapis.com/v1/subscriptions', {
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            targetResource: `//chat.googleapis.com/${spaceName}`,
+            eventTypes: ['google.workspace.chat.message.v1.created'],
+            payloadOptions: { includeResource: true },
+            notificationEndpoint: {
+              pubsubTopic: `projects/${config.projectId}/topics/${config.topicName}`,
+            },
+          }),
+        });
+
+        if (res.ok) {
+          const subData = (await res.json()) as { name: string; expireTime: string };
+          await updateGoogleChatState((latestState) => {
+            const currentMap = latestState.channelChatMap || {};
+            return {
+              channelChatMap: {
+                ...currentMap,
+                [externalContextId]: {
+                  ...(currentMap[externalContextId] || {}),
+                  subscriptionId: subData.name,
+                  expirationDate: subData.expireTime,
+                },
+              },
+            };
+          });
+          console.log(`Created subscription ${subData.name} for space ${externalContextId}`);
+        } else {
+          const errText = await res.text();
+          console.error(`Failed to create subscription for space ${externalContextId}:`, errText);
+        }
+      }
+    } catch (err) {
+      console.error('Error setting up subscription on ADDED_TO_SPACE:', err);
+    }
+  }
+
+  if (targetChatId && mappedChatId) {
+    try {
+      const authClient = await getAuthClient();
+      const chatApi = google.chat({ version: 'v1', auth: authClient });
+      await chatApi.spaces.messages.create({
+        parent: externalContextId,
+        requestBody: {
+          text: `Hello! I am currently mapped to chat \`${targetChatId}\`.`,
+        },
+      });
+    } catch (err) {
+      console.error('Failed to send greeting on ADDED_TO_SPACE:', err);
+    }
+  }
+}
+
+export async function handleRemovedFromSpace(
+  externalContextId: string,
+  currentState: GoogleChatState,
+  config: GoogleChatConfig
+) {
+  const subId = currentState.channelChatMap?.[externalContextId]?.subscriptionId;
+  if (subId) {
+    try {
+      const userAuthClient = await getUserAuthClient(config);
+      const tokenResponse = await userAuthClient.getAccessToken();
+      const token = tokenResponse.token;
+
+      if (token) {
+        const res = await fetch(`https://workspaceevents.googleapis.com/v1/${subId}`, {
+          method: 'DELETE',
+          headers: {
+            Authorization: `Bearer ${token}`,
+          },
+        });
+
+        if (res.ok) {
+          console.log(`Deleted subscription ${subId}`);
+        } else {
+          const errText = await res.text();
+          console.error(`Failed to delete subscription ${subId}:`, errText);
+        }
+      }
+    } catch (err) {
+      console.error('Error tearing down subscription on REMOVED_FROM_SPACE:', err);
+    }
+  }
+
+  await updateGoogleChatState((latestState) => {
+    const map = { ...(latestState.channelChatMap || {}) };
+    const entry = map[externalContextId];
+    if (entry) {
+      if (!entry.chatId) {
+        delete map[externalContextId];
+      } else {
+        delete entry.subscriptionId;
+        delete entry.expirationDate;
+      }
+    }
+    return { channelChatMap: map };
+  });
+}

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

@@ -0,0 +1,88 @@
+import { google } from 'googleapis';
+import path from 'node:path';
+import fs from 'node:fs';
+import mime from 'mime-types';
+import type { GoogleChatConfig } from './config.js';
+import { getUserAuthClient } from './auth.js';
+import { getWorkspaceRoot } from '../shared/workspace.js';
+
+export async function uploadFilesToDrive(
+  files: string[],
+  config: GoogleChatConfig
+): Promise<string[]> {
+  const driveClient = await getUserAuthClient(config);
+  const driveApi = google.drive({ version: 'v3', auth: driveClient });
+  const workspaceRoot = getWorkspaceRoot(process.cwd());
+
+  let folderId: string | undefined;
+  try {
+    const queryRes = await driveApi.files.list({
+      q: "mimeType='application/vnd.google-apps.folder' and name='Clawmini Uploads' and trashed=false",
+      fields: 'files(id)',
+    });
+    if (queryRes.data.files && queryRes.data.files.length > 0) {
+      folderId = queryRes.data.files[0]!.id!;
+    } else {
+      const folderRes = await driveApi.files.create({
+        requestBody: {
+          name: 'Clawmini Uploads',
+          mimeType: 'application/vnd.google-apps.folder',
+        },
+        fields: 'id',
+      });
+      if (folderRes.data.id) {
+        folderId = folderRes.data.id;
+      }
+    }
+  } catch (err) {
+    console.error('Failed to create or find Clawmini Uploads folder', err);
+  }
+
+  const uploadPromises = files.map(async (fileRelPath) => {
+    const filePath = path.resolve(workspaceRoot, fileRelPath);
+    if (!fs.existsSync(filePath)) return null;
+
+    const fileName = path.basename(filePath);
+    const mimeType = mime.lookup(filePath) || 'application/octet-stream';
+
+    try {
+      const driveRes = await driveApi.files.create({
+        requestBody: {
+          name: fileName,
+          ...(folderId ? { parents: [folderId] } : {}),
+        },
+        media: { mimeType, body: fs.createReadStream(filePath) },
+        fields: 'id, webViewLink',
+      });
+
+      if (driveRes.data.id && driveRes.data.webViewLink) {
+        const fileId = driveRes.data.id;
+        try {
+          await Promise.all(
+            config.authorizedUsers.map((email) =>
+              driveApi.permissions.create({
+                fileId,
+                requestBody: {
+                  type: 'user',
+                  role: 'reader',
+                  emailAddress: email,
+                },
+                sendNotificationEmail: false,
+              })
+            )
+          );
+        } catch (err) {
+          console.error(`Failed to grant permissions for ${fileName}`, err);
+        }
+        return driveRes.data.webViewLink;
+      }
+      return null;
+    } catch (err) {
+      console.error(`Failed to upload file ${fileName} to Google Drive`, err);
+      return `*(Failed to upload to Drive: ${fileName})*`;
+    }
+  });
+
+  const uploadResults = await Promise.all(uploadPromises);
+  return uploadResults.filter((r) => r !== null) as string[];
+}

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

@@ -0,0 +1,111 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { downloadAttachment, resetAuthClient } from './utils.js';
+import { google } from 'googleapis';
+import { EventEmitter } from 'node:events';
+
+vi.mock('googleapis', () => {
+  return {
+    google: {
+      auth: {
+        getClient: vi.fn(),
+      },
+    },
+  };
+});
+
+describe('downloadAttachment', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    resetAuthClient();
+  });
+
+  it('should successfully download an attachment within the size limit', async () => {
+    const mockStream = new EventEmitter();
+    // @ts-expect-error Mocking the stream destroy
+    mockStream.destroy = vi.fn();
+
+    const mockRequest = vi.fn().mockResolvedValue({
+      data: mockStream,
+    });
+
+    // @ts-expect-error Mocking the client
+    vi.mocked(google.auth.getClient).mockResolvedValue({
+      request: mockRequest,
+    });
+
+    const promise = downloadAttachment('spaces/123/messages/456/attachments/789');
+
+    await new Promise(setImmediate);
+
+    // Simulate stream data and end
+    mockStream.emit('data', Buffer.alloc(1024));
+    mockStream.emit('end');
+
+    const buffer = await promise;
+
+    expect(google.auth.getClient).toHaveBeenCalledWith({
+      scopes: ['https://www.googleapis.com/auth/chat.bot'],
+    });
+    expect(mockRequest).toHaveBeenCalledWith({
+      url: 'https://chat.googleapis.com/v1/media/spaces/123/messages/456/attachments/789?alt=media',
+      method: 'GET',
+      responseType: 'stream',
+    });
+    expect(buffer).toBeInstanceOf(Buffer);
+    expect(buffer.length).toBe(1024);
+  });
+
+  it('should throw an error if the attachment exceeds the maximum size', async () => {
+    const maxSizeBytes = 25 * 1024 * 1024;
+    const mockStream = new EventEmitter();
+    // @ts-expect-error Mocking the stream destroy
+    mockStream.destroy = vi.fn();
+
+    const mockRequest = vi.fn().mockResolvedValue({
+      data: mockStream,
+    });
+
+    // @ts-expect-error Mocking the client
+    vi.mocked(google.auth.getClient).mockResolvedValue({
+      request: mockRequest,
+    });
+
+    const promise = downloadAttachment('spaces/123/messages/456/attachments/789');
+
+    await new Promise(setImmediate);
+
+    // Simulate stream data exceeding the limit
+    mockStream.emit('data', Buffer.alloc(maxSizeBytes + 1));
+
+    await expect(promise).rejects.toThrow('Attachment exceeds maximum size');
+    // @ts-expect-error Mocking the stream destroy
+    expect(mockStream.destroy).toHaveBeenCalled();
+  });
+
+  it('should throw an error if the attachment exceeds a custom maximum size', async () => {
+    const maxSizeBytes = 10 * 1024 * 1024;
+    const mockStream = new EventEmitter();
+    // @ts-expect-error Mocking the stream destroy
+    mockStream.destroy = vi.fn();
+
+    const mockRequest = vi.fn().mockResolvedValue({
+      data: mockStream,
+    });
+
+    // @ts-expect-error Mocking the client
+    vi.mocked(google.auth.getClient).mockResolvedValue({
+      request: mockRequest,
+    });
+
+    const promise = downloadAttachment('spaces/123/messages/456/attachments/789', 10);
+
+    await new Promise(setImmediate);
+
+    // Simulate stream data exceeding the limit
+    mockStream.emit('data', Buffer.alloc(maxSizeBytes + 1));
+
+    await expect(promise).rejects.toThrow('Attachment exceeds maximum size');
+    // @ts-expect-error Mocking the stream destroy
+    expect(mockStream.destroy).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,133 @@
+import { google } from 'googleapis';
+import type { Readable } from 'node:stream';
+import type { ChatMessage } from '../shared/chats.js';
+
+let authClient: Awaited<ReturnType<typeof google.auth.getClient>> | null = null;
+
+export function resetAuthClient(): void {
+  authClient = null;
+}
+
+export function buildPolicyCard(logMessage: ChatMessage) {
+  const policyId = ('requestId' in logMessage && logMessage.requestId) || logMessage.id;
+  return [
+    {
+      cardId: logMessage.id,
+      card: {
+        header: {
+          title: 'Action Required: Policy Approval',
+          subtitle: 'A request needs your review.',
+        },
+        sections: [
+          {
+            widgets: [
+              {
+                textParagraph: {
+                  text: logMessage.content || 'Please review this request.',
+                },
+              },
+              {
+                buttonList: {
+                  buttons: [
+                    {
+                      text: 'Approve',
+                      color: {
+                        red: 0,
+                        green: 0.5,
+                        blue: 0,
+                        alpha: 1,
+                      },
+                      onClick: {
+                        action: {
+                          function: 'approve',
+                          parameters: [{ key: 'policyId', value: policyId }],
+                        },
+                      },
+                    },
+                    {
+                      text: 'Reject',
+                      color: {
+                        red: 0.8,
+                        green: 0,
+                        blue: 0,
+                        alpha: 1,
+                      },
+                      onClick: {
+                        action: {
+                          function: 'reject',
+                          parameters: [{ key: 'policyId', value: policyId }],
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        ],
+      },
+    },
+  ];
+}
+
+export function chunkString(str: string, size: number): string[] {
+  const chunks: string[] = [];
+  const chars = Array.from(str);
+  for (let i = 0; i < chars.length; i += size) {
+    chunks.push(chars.slice(i, i + size).join(''));
+  }
+  return chunks;
+}
+
+/**
+ * Downloads a file attachment securely using Application Default Credentials (ADC).
+ * @param resourceName The resourceName of the attachment data to download.
+ * @param maxAttachmentSizeMB The maximum allowed attachment size in MB (defaults to 25).
+ * @returns A Buffer containing the file data.
+ */
+export async function downloadAttachment(
+  resourceName: string,
+  maxAttachmentSizeMB: number = 25
+): Promise<Buffer> {
+  // Use ADC to authenticate
+  if (!authClient) {
+    authClient = await google.auth.getClient({
+      scopes: ['https://www.googleapis.com/auth/chat.bot'],
+    });
+  }
+  const client = authClient;
+
+  const url = `https://chat.googleapis.com/v1/media/${resourceName}?alt=media`;
+
+  const response = await client.request<Readable>({
+    url,
+    method: 'GET',
+    responseType: 'stream',
+  });
+
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    let totalBytes = 0;
+    const maxSizeBytes = maxAttachmentSizeMB * 1024 * 1024;
+
+    response.data.on('data', (chunk: Buffer) => {
+      totalBytes += chunk.length;
+      if (totalBytes > maxSizeBytes) {
+        response.data.destroy();
+        reject(
+          new Error(`Attachment exceeds maximum size of ${maxSizeBytes} bytes: ${totalBytes} bytes`)
+        );
+      } else {
+        chunks.push(chunk);
+      }
+    });
+
+    response.data.on('end', () => {
+      resolve(Buffer.concat(chunks));
+    });
+
+    response.data.on('error', (err: Error) => {
+      reject(err);
+    });
+  });
+}

package/src/cli/commands/init.ts

@@ -37,13 +37,6 @@ export const initCmd = new Command('init')
         },
         env: {},
       },
-      routers: [
-        '@clawmini/slash-new',
-        '@clawmini/slash-stop',
-        '@clawmini/slash-interrupt',
-        '@clawmini/slash-policies',
-        '@clawmini/slash-command',
-      ],
       api: true,
     };
 

package/src/cli/commands/messages.ts

@@ -76,15 +76,30 @@ messagesCmd
   .action(async (options) => {
     try {
       const chatId = options.chat ?? (await getDefaultChatId());
-      const messages = await getMessages(chatId, options.lines);
+      const messages = await getMessages(
+        chatId,
+        options.lines,
+        undefined,
+        (msg) => !msg.subagentId
+      );
 
       if (options.json) {
         messages.forEach((msg) => console.log(JSON.stringify(msg)));
       } else {
         messages.forEach((msg) => {
-          if (msg.role === 'user') {
+          if (msg.role === 'user' || msg.displayRole === 'user') {
             console.log(`[USER] ${msg.content}`);
-          } else if (msg.role === 'log') {
+          } else if (msg.role === 'agent' || msg.displayRole === 'agent') {
+            console.log(`[AGENT] ${msg.content.trim()}`);
+          } else if (msg.role === 'policy') {
+            console.log(`[POLICY] ${msg.commandName} ${msg.args.join(' ')}`);
+          } else if (msg.role === 'tool') {
+            console.log(`[TOOL] ${msg.name}`);
+          } else if (msg.role === 'system') {
+            if (msg.content) {
+              console.log(`[LOG] ${msg.content.trim()}`);
+            }
+          } else if (msg.role === 'command' || msg.role === 'legacy_log') {
             if (msg.content) {
               console.log(`[LOG] ${msg.content.trim()}`);
             } else if (msg.stderr) {

package/src/cli/commands/policies.ts

@@ -0,0 +1,70 @@
+import { Command } from 'commander';
+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 { getClawminiDir } from '../../shared/workspace.js';
+
+const SUPPORTED_POLICIES = ['propose-policy'];
+
+export const policiesCmd = new Command('policies').description('Manage sandbox policies');
+
+policiesCmd
+  .command('add <name>')
+  .description('Add a new policy')
+  .action(async (name: string) => {
+    if (!SUPPORTED_POLICIES.includes(name)) {
+      handleError(
+        'add policy',
+        new Error(
+          `Unsupported policy: "${name}". Supported policies: ${SUPPORTED_POLICIES.join(', ')}`
+        )
+      );
+    }
+
+    const dirPath = getClawminiDir();
+    const policyScriptsDir = path.join(dirPath, 'policy-scripts');
+    const policiesPath = path.join(dirPath, 'policies.json');
+
+    if (!fs.existsSync(dirPath)) {
+      handleError(
+        'add policy',
+        new Error('.clawmini directory not found. Please run "clawmini init" first.')
+      );
+    }
+
+    if (!fs.existsSync(policyScriptsDir)) {
+      fs.mkdirSync(policyScriptsDir, { recursive: true });
+    }
+
+    // Update or create policies.json
+    let policies: PolicyConfig = { policies: {} };
+    if (fs.existsSync(policiesPath)) {
+      policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
+    }
+
+    policies.policies[name] = {
+      description: 'Propose a new policy to create',
+      command: `./.clawmini/policy-scripts/${name}.js`,
+      allowHelp: true,
+    };
+
+    fs.writeFileSync(policiesPath, JSON.stringify(policies, null, 2));
+    console.log(`Registered ${name} in .clawmini/policies.json`);
+
+    try {
+      const foundPath = await resolveCompiledScript(name, import.meta.url);
+      let scriptContent = fs.readFileSync(foundPath, 'utf8');
+
+      if (!scriptContent.startsWith('#!')) {
+        scriptContent = '#!/usr/bin/env node\n' + scriptContent;
+      }
+
+      const destPath = path.join(policyScriptsDir, `${name}.js`);
+      fs.writeFileSync(destPath, scriptContent, { mode: 0o755 });
+      console.log(`Copied ${name} script to ${destPath}`);
+    } catch (err) {
+      handleError('add policy', err);
+    }
+  });

package/src/cli/commands/skills.ts

@@ -0,0 +1,71 @@
+import { Command } from 'commander';
+import { promises as fsPromises, Dirent } from 'fs';
+import {
+  resolveSkillsTemplatePath,
+  copyAgentSkills,
+  copyAgentSkill,
+} from '../../shared/workspace.js';
+import { handleError } from '../utils.js';
+
+export const skillsCmd = new Command('skills').description('Manage template skills');
+
+skillsCmd
+  .command('list')
+  .description('List available template skills')
+  .action(async () => {
+    try {
+      let skillsDir: string;
+      try {
+        skillsDir = await resolveSkillsTemplatePath();
+      } catch (err: unknown) {
+        if (err instanceof Error && err.message.includes('Template not found: skills')) {
+          console.error('No skills found. The templates/skills directory does not exist.');
+          return;
+        }
+        throw err;
+      }
+
+      let entries: Dirent[];
+      try {
+        entries = await fsPromises.readdir(skillsDir, { withFileTypes: true });
+      } catch (err: unknown) {
+        if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+          console.error('No skills found.');
+          return;
+        }
+        throw err;
+      }
+
+      const skills = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+
+      if (skills.length === 0) {
+        console.error('No skills found.');
+        return;
+      }
+      for (const skill of skills) {
+        console.log(`- ${skill}`);
+      }
+    } catch (err) {
+      handleError('list skills', err);
+    }
+  });
+
+skillsCmd
+  .command('add [skill-name]')
+  .description('Add a skill to an agent, overwriting the target skill directory if it exists')
+  .option('-a, --agent <agentId>', 'Agent ID (defaults to "default")')
+  .action(async (skillName: string | undefined, options: { agent?: string }) => {
+    try {
+      const agentId = options.agent || 'default';
+
+      if (skillName) {
+        await copyAgentSkill(agentId, skillName, process.cwd(), true);
+        console.log(`Successfully added skill '${skillName}' to agent '${agentId}'.`);
+      } else {
+        await copyAgentSkills(agentId, process.cwd(), true);
+        console.log(`Successfully added all skills to agent '${agentId}'.`);
+      }
+    } catch (err) {
+      handleError('add skill', err);
+    }
+  });

package/src/cli/commands/web-api/chats.ts

@@ -52,8 +52,12 @@ export async function handleApiChats(
     try {
       const url = new URL(req.url || '', `http://${req.headers.host}`);
       const since = url.searchParams.get('since');
+      const before = url.searchParams.get('before');
+      const limitParam = url.searchParams.get('limit');
+      const parsedLimit = limitParam ? parseInt(limitParam, 10) : undefined;
+      const limit = Number.isNaN(parsedLimit) ? undefined : parsedLimit;
 
-      let messages = await getMessages(chatId);
+      let messages = await getMessages(chatId, limit, undefined, undefined, before || undefined);
 
       if (since) {
         const sinceIndex = messages.findIndex((m) => m.id === since);

package/src/cli/e2e/basic.test.ts

@@ -39,5 +39,5 @@ describe('E2E Basic Tests', () => {
     const { stdout: stdoutDelete } = await runCli(['chats', 'delete', 'test-chat']);
     expect(stdoutDelete).toContain('Chat test-chat deleted successfully.');
     expect(fs.existsSync(path.join(chatsDir, 'test-chat'))).toBe(false);
-  });
+  }, 15000);
 });

package/src/cli/e2e/cron.test.ts

@@ -65,7 +65,7 @@ describe('E2E Cron Tests', () => {
     const { stdout: stdoutList3 } = await runCli(['jobs', 'list']);
     expect(stdoutList3).not.toContain('test-job-1');
     expect(stdoutList3).toContain('- test-job-2 (cron: * * * * *)');
-  });
+  }, 15000);
 
   it('should execute a job and inherit chat default agent and session', async () => {
     // 1. Create a specific agent for this chat