clawmini 0.0.1

package/src/adapter-discord/index.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
+import { readDiscordConfig, isAuthorized, initDiscordConfig } from './config.js';
+import { getTRPCClient } from './client.js';
+import { startDaemonToDiscordForwarder } from './forwarder.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export async function main() {
+  const args = process.argv.slice(2);
+
+  if (args[0] === 'init') {
+    await initDiscordConfig();
+    return;
+  }
+
+  console.log('Discord Adapter starting...');
+
+  const config = await readDiscordConfig();
+  if (!config) {
+    console.error(
+      'Failed to load Discord configuration. Please ensure .clawmini/adapters/discord/config.json exists and is valid.'
+    );
+    process.exit(1);
+  }
+
+  const trpc = getTRPCClient();
+
+  const client = new Client({
+    intents: [GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
+    partials: [Partials.Channel],
+  });
+
+  client.once(Events.ClientReady, (readyClient) => {
+    console.log(`Ready! Logged in as ${readyClient.user.tag}`);
+
+    // Start forwarding from daemon to Discord
+    startDaemonToDiscordForwarder(readyClient, trpc, config.authorizedUserId, config.chatId).catch(
+      (error) => {
+        console.error('Error in daemon-to-discord forwarder:', error);
+      }
+    );
+  });
+
+  client.on(Events.MessageCreate, async (message) => {
+    // Ignore messages from the bot itself
+    if (message.author.id === client.user?.id) return;
+
+    // Only handle DM messages
+    if (message.guild) return;
+
+    // Check if the user is authorized
+    if (!isAuthorized(message.author.id, config.authorizedUserId)) {
+      console.log(
+        `Unauthorized message from ${message.author.tag} (${message.author.id}) ignored.`
+      );
+      return;
+    }
+
+    console.log(`Received message from ${message.author.tag}: ${message.content}`);
+
+    const downloadedFiles: string[] = [];
+    if (message.attachments.size > 0) {
+      const { getClawminiDir } = await import('../shared/workspace.js');
+      const tmpDir = path.join(getClawminiDir(process.cwd()), 'tmp', 'discord');
+      await fs.mkdir(tmpDir, { recursive: true });
+      const maxSizeMB = config.maxAttachmentSizeMB ?? 25;
+      const maxSizeBytes = maxSizeMB * 1024 * 1024;
+
+      for (const attachment of message.attachments.values()) {
+        if (attachment.size > maxSizeBytes) {
+          console.warn(
+            `Attachment ${attachment.name} exceeds size limit (${maxSizeMB}MB). Ignoring.`
+          );
+          await message.reply(
+            `Warning: Attachment ${attachment.name} exceeds the size limit of ${maxSizeMB}MB and was ignored.`
+          );
+          continue;
+        }
+
+        try {
+          const res = await fetch(attachment.url);
+          if (!res.ok) {
+            console.error(`Failed to download attachment ${attachment.name}`);
+            continue;
+          }
+
+          const uniqueName = `${Date.now()}-${attachment.name}`;
+          const filePath = path.join(tmpDir, uniqueName);
+          const arrayBuffer = await res.arrayBuffer();
+          await fs.writeFile(filePath, Buffer.from(arrayBuffer));
+          downloadedFiles.push(filePath);
+        } catch (err) {
+          console.error(`Error downloading attachment ${attachment.name}:`, err);
+        }
+      }
+    }
+
+    let finalContent = message.content;
+
+    if (message.reference && message.reference.messageId) {
+      try {
+        const referencedMessage = await message.fetchReference();
+        if (referencedMessage && referencedMessage.content) {
+          const quotedContent = referencedMessage.content
+            .split('\n')
+            .map((line) => `> ${line}`)
+            .join('\n');
+          finalContent = `${quotedContent}\n${finalContent}`;
+        }
+      } catch (err) {
+        console.error('Failed to fetch referenced message:', err);
+      }
+    }
+
+    console.log(`Forwarding message to daemon: ${finalContent}`);
+    try {
+      await trpc.sendMessage.mutate({
+        type: 'send-message',
+        client: 'cli',
+        data: {
+          message: finalContent,
+          chatId: config.chatId,
+          files: downloadedFiles.length > 0 ? downloadedFiles : undefined,
+          adapter: 'discord',
+          noWait: true,
+        },
+      });
+      console.log('Message forwarded to daemon successfully.');
+    } catch (error) {
+      console.error('Failed to forward message to daemon:', error);
+    }
+  });
+
+  try {
+    await client.login(config.botToken);
+  } catch (error) {
+    console.error('Failed to login to Discord:', error);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error('Unhandled error in Discord Adapter:', error);
+  process.exit(1);
+});

package/src/adapter-discord/state.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { readDiscordState, writeDiscordState, getDiscordStatePath } from './state.js';
+
+vi.mock('node:fs/promises');
+vi.mock('../shared/workspace.js', () => ({
+  getClawminiDir: vi.fn(() => '/mock/clawmini'),
+  getWorkspaceRoot: vi.fn(() => '/mock/workspace'),
+}));
+
+describe('Discord State Management', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return default state if file does not exist', async () => {
+    vi.mocked(fsPromises.readFile).mockRejectedValue(new Error('File not found'));
+
+    const state = await readDiscordState();
+    expect(state).toEqual({ lastSyncedMessageId: undefined });
+  });
+
+  it('should read state from file', async () => {
+    const mockState = { lastSyncedMessageId: '12345' };
+    vi.mocked(fsPromises.readFile).mockResolvedValue(JSON.stringify(mockState));
+
+    const state = await readDiscordState();
+    expect(state).toEqual(mockState);
+  });
+
+  it('should return default state if file contains invalid JSON', async () => {
+    vi.mocked(fsPromises.readFile).mockResolvedValue('invalid-json');
+
+    const state = await readDiscordState();
+    expect(state).toEqual({ lastSyncedMessageId: undefined });
+  });
+
+  it('should write state to file', async () => {
+    const mockState = { lastSyncedMessageId: '67890' };
+    const statePath = getDiscordStatePath();
+
+    await writeDiscordState(mockState);
+
+    expect(fsPromises.mkdir).toHaveBeenCalledWith(path.dirname(statePath), { recursive: true });
+    expect(fsPromises.writeFile).toHaveBeenCalledWith(
+      statePath,
+      JSON.stringify(mockState, null, 2),
+      'utf-8'
+    );
+  });
+
+  it('should handle errors when writing state', async () => {
+    vi.mocked(fsPromises.writeFile).mockRejectedValue(new Error('Permission denied'));
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await writeDiscordState({ lastSyncedMessageId: '123' });
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to write Discord state'),
+      expect.any(Error)
+    );
+    consoleSpy.mockRestore();
+  });
+});

package/src/adapter-discord/state.ts

@@ -0,0 +1,44 @@
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { getClawminiDir } from '../shared/workspace.js';
+
+export const DiscordStateSchema = z.object({
+  lastSyncedMessageId: z.string().optional(),
+});
+
+export type DiscordState = z.infer<typeof DiscordStateSchema>;
+
+export function getDiscordStatePath(startDir = process.cwd()): string {
+  return path.join(getClawminiDir(startDir), 'adapters', 'discord', 'state.json');
+}
+
+export async function readDiscordState(startDir = process.cwd()): Promise<DiscordState> {
+  const statePath = getDiscordStatePath(startDir);
+  try {
+    const data = await fsPromises.readFile(statePath, 'utf-8');
+    const parsed = JSON.parse(data);
+    const result = DiscordStateSchema.safeParse(parsed);
+    if (!result.success) {
+      return { lastSyncedMessageId: undefined };
+    }
+    return result.data;
+  } catch {
+    // Return default state if file doesn't exist or is invalid JSON
+    return { lastSyncedMessageId: undefined };
+  }
+}
+
+export async function writeDiscordState(
+  state: DiscordState,
+  startDir = process.cwd()
+): Promise<void> {
+  const statePath = getDiscordStatePath(startDir);
+  const dir = path.dirname(statePath);
+  try {
+    await fsPromises.mkdir(dir, { recursive: true });
+    await fsPromises.writeFile(statePath, JSON.stringify(state, null, 2), 'utf-8');
+  } catch (err) {
+    console.error(`Failed to write Discord state to ${statePath}:`, err);
+  }
+}

package/src/cli/client.ts

@@ -0,0 +1,46 @@
+import { createTRPCClient, httpLink } from '@trpc/client';
+import type { AppRouter } from '../daemon/router.js';
+import { getSocketPath, getClawminiDir } from '../shared/workspace.js';
+import { createUnixSocketFetch } from '../shared/fetch.js';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export async function getDaemonClient(options: { autoStart?: boolean } = {}) {
+  const { autoStart = true } = options;
+  const socketPath = getSocketPath();
+
+  // Check if server is running by verifying socket exists
+  // (A better check would be to ping it, but this is a start)
+  if (!fs.existsSync(socketPath)) {
+    if (!autoStart) {
+      throw new Error('Daemon not running.');
+    }
+    console.log('Daemon not running. Starting daemon...');
+
+    // Start daemon in the background
+    const daemonPath = new URL('../daemon/index.mjs', import.meta.url).pathname;
+    const logFile = fs.openSync(path.join(getClawminiDir(), 'daemon.log'), 'a');
+    const child = spawn(process.execPath, [daemonPath], {
+      detached: true,
+      stdio: ['ignore', logFile, logFile],
+    });
+    child.unref();
+
+    // Wait a moment for the daemon to start and create the socket
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    if (!fs.existsSync(socketPath)) {
+      throw new Error('Failed to start daemon.');
+    }
+  }
+
+  return createTRPCClient<AppRouter>({
+    links: [
+      httpLink({
+        url: 'http://localhost',
+        fetch: createUnixSocketFetch(socketPath),
+      }),
+    ],
+  });
+}

package/src/cli/commands/agents.ts

@@ -0,0 +1,138 @@
+import { Command } from 'commander';
+import {
+  listAgents,
+  getAgent,
+  writeAgentSettings,
+  deleteAgent,
+  isValidAgentId,
+} from '../../shared/workspace.js';
+import { type Agent } from '../../shared/config.js';
+import { createAgentWithChat } from '../../shared/agent-utils.js';
+import { handleError } from '../utils.js';
+
+export const agentsCmd = new Command('agents').description('Manage agents');
+
+function parseEnv(envArray: string[] | undefined): Record<string, string> | undefined {
+  if (!envArray || envArray.length === 0) return undefined;
+  const env: Record<string, string> = {};
+  for (const e of envArray) {
+    const [key, ...rest] = e.split('=');
+    if (key && rest.length >= 0) {
+      env[key] = rest.join('=');
+    }
+  }
+  return env;
+}
+
+function assertValidAgentId(id: string): void {
+  if (!isValidAgentId(id)) {
+    throw new Error(`Invalid agent ID: ${id}`);
+  }
+}
+
+agentsCmd
+  .command('list')
+  .description('Display existing agents')
+  .action(async () => {
+    try {
+      const agents = await listAgents();
+      if (agents.length === 0) {
+        console.log('No agents found.');
+        return;
+      }
+      for (const id of agents) {
+        console.log(`- ${id}`);
+      }
+    } catch (err) {
+      handleError('list agents', err);
+    }
+  });
+
+agentsCmd
+  .command('add <id>')
+  .description('Create a new agent')
+  .option('-d, --directory <dir>', 'Working directory for the agent')
+  .option('-t, --template <name>', 'Template to use for the agent')
+  .option(
+    '-e, --env <env...>',
+    'Environment variables in KEY=VALUE format (can be specified multiple times)'
+  )
+  .action(
+    async (id: string, options: { directory?: string; template?: string; env?: string[] }) => {
+      try {
+        assertValidAgentId(id);
+        const existing = await getAgent(id);
+        if (existing) {
+          throw new Error(`Agent ${id} already exists.`);
+        }
+
+        const agentData: Agent = {};
+
+        if (options.directory) {
+          agentData.directory = options.directory;
+        }
+        const env = parseEnv(options.env);
+        if (env) {
+          agentData.env = { ...(agentData.env || {}), ...env };
+        }
+
+        await createAgentWithChat(id, agentData, options.template);
+
+        console.log(`Agent ${id} created successfully.`);
+      } catch (err) {
+        handleError('create agent', err);
+      }
+    }
+  );
+
+agentsCmd
+  .command('update <id>')
+  .description('Update an existing agent')
+  .option('-d, --directory <dir>', 'Working directory for the agent')
+  .option(
+    '-e, --env <env...>',
+    'Environment variables in KEY=VALUE format (can be specified multiple times)'
+  )
+  .action(async (id: string, options: { directory?: string; env?: string[] }) => {
+    try {
+      assertValidAgentId(id);
+      const existing = await getAgent(id);
+      if (!existing) {
+        throw new Error(`Agent ${id} does not exist.`);
+      }
+
+      const agentData: Agent = { ...existing };
+
+      if (options.directory !== undefined) {
+        agentData.directory = options.directory;
+      }
+
+      const env = parseEnv(options.env);
+      if (env) {
+        agentData.env = { ...(agentData.env || {}), ...env };
+      }
+
+      await writeAgentSettings(id, agentData);
+      console.log(`Agent ${id} updated successfully.`);
+    } catch (err) {
+      handleError('update agent', err);
+    }
+  });
+
+agentsCmd
+  .command('delete <id>')
+  .description('Remove an agent')
+  .action(async (id: string) => {
+    try {
+      assertValidAgentId(id);
+      const existing = await getAgent(id);
+      if (!existing) {
+        throw new Error(`Agent ${id} does not exist.`);
+      }
+
+      await deleteAgent(id);
+      console.log(`Agent ${id} deleted successfully.`);
+    } catch (err) {
+      handleError('delete agent', err);
+    }
+  });

package/src/cli/commands/chats.ts

@@ -0,0 +1,79 @@
+import { Command } from 'commander';
+import {
+  listChats,
+  createChat,
+  deleteChat,
+  setDefaultChatId,
+  getDefaultChatId,
+  DEFAULT_CHAT_ID,
+} from '../../shared/chats.js';
+
+export const chatsCmd = new Command('chats').description('Manage chat sessions');
+
+chatsCmd
+  .command('list')
+  .description('Display existing chats')
+  .action(async () => {
+    try {
+      const chats = await listChats();
+      const defaultId = await getDefaultChatId();
+      if (chats.length === 0) {
+        console.log('No chats found.');
+        return;
+      }
+      for (const id of chats) {
+        const marker = id === defaultId ? ' *' : '';
+        console.log(`- ${id}${marker}`);
+      }
+    } catch (err) {
+      console.error('Failed to list chats:', err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+
+chatsCmd
+  .command('add <id>')
+  .description('Initialize a new chat')
+  .action(async (id: string) => {
+    try {
+      await createChat(id);
+      console.log(`Chat ${id} created successfully.`);
+    } catch (err) {
+      console.error('Failed to create chat:', err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+
+chatsCmd
+  .command('delete <id>')
+  .description('Remove a chat')
+  .action(async (id: string) => {
+    try {
+      const defaultId = await getDefaultChatId();
+      await deleteChat(id);
+      console.log(`Chat ${id} deleted successfully.`);
+      if (id === defaultId) {
+        await setDefaultChatId(DEFAULT_CHAT_ID);
+        console.log(`Default chat reset to default.`);
+      }
+    } catch (err) {
+      console.error('Failed to delete chat:', err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+
+chatsCmd
+  .command('set-default <id>')
+  .description('Update the workspace default chat')
+  .action(async (id: string) => {
+    try {
+      await setDefaultChatId(id);
+      console.log(`Default chat set to ${id}.`);
+    } catch (err) {
+      console.error(
+        'Failed to set default chat:',
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(1);
+    }
+  });

package/src/cli/commands/down.ts

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { getDaemonClient } from '../client.js';
+import { getSocketPath } from '../../shared/workspace.js';
+import fs from 'node:fs';
+
+export const downCmd = new Command('down')
+  .description('Stop the local clawmini daemon server')
+  .action(async () => {
+    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('.');
+      }
+      console.log('\nSuccessfully shut down clawmini daemon.');
+    } catch (err: unknown) {
+      if (err instanceof Error && err.message === 'Daemon not running.') {
+        console.log('Daemon is not running.');
+      } else {
+        console.error(
+          '\nFailed to shut down daemon:',
+          err instanceof Error ? err.message : String(err)
+        );
+        process.exit(1);
+      }
+    }
+  });

package/src/cli/commands/environments.ts

@@ -0,0 +1,39 @@
+import { Command } from 'commander';
+import { readSettings, writeSettings, enableEnvironment } from '../../shared/workspace.js';
+import { handleError } from '../utils.js';
+
+export const environmentsCmd = new Command('environments').description('Manage environments');
+
+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 }) => {
+    try {
+      await enableEnvironment(name, options.path);
+    } catch (err) {
+      handleError('enable environment', err);
+    }
+  });
+
+environmentsCmd
+  .command('disable')
+  .description('Disable an environment mapping')
+  .option('-p, --path <subpath>', 'Path to remove the environment from', './')
+  .action(async (options: { path: string }) => {
+    try {
+      const settings = await readSettings();
+      if (!settings?.environments || !settings.environments[options.path]) {
+        console.log(`No environment mapping found for path '${options.path}'.`);
+        return;
+      }
+
+      const name = settings.environments[options.path];
+      delete settings.environments[options.path];
+      await writeSettings(settings);
+
+      console.log(`Disabled environment '${name}' for path '${options.path}'.`);
+    } catch (err) {
+      handleError('disable environment', err);
+    }
+  });

package/src/cli/commands/export-lite.ts

@@ -0,0 +1,62 @@
+import { Command } from 'commander';
+import path from 'node:path';
+import {
+  getLiteScriptContent,
+  writeLiteScript,
+  exportLiteToAllEnvironments,
+} from '../../shared/lite.js';
+
+export const exportLiteCmd = new Command('export-lite')
+  .description('Export the standalone clawmini-lite client script')
+  .option(
+    '-o, --out <path>',
+    'Output path or directory for the script (defaults to current directory)'
+  )
+  .option('--stdout', 'Output the script to stdout instead of a file')
+  .action(async (options: { out?: string; stdout?: boolean }) => {
+    let liteScriptContent = '';
+    try {
+      liteScriptContent = await getLiteScriptContent();
+    } catch (err) {
+      console.error(
+        `Failed to read compiled clawmini-lite script. Ensure you have built the project (npm run build). Error: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+
+    if (options.stdout) {
+      process.stdout.write(liteScriptContent);
+      return;
+    }
+
+    const defaultFilename = 'clawmini-lite.js';
+    let finalPath = path.resolve(process.cwd(), defaultFilename);
+
+    if (options.out) {
+      finalPath = path.resolve(process.cwd(), options.out);
+      try {
+        const writtenPath = await writeLiteScript(finalPath);
+        console.log(`Successfully exported clawmini-lite to ${writtenPath}`);
+      } catch (err) {
+        console.error(
+          `Failed to export script: ${err instanceof Error ? err.message : String(err)}`
+        );
+        process.exit(1);
+      }
+      return;
+    }
+
+    const exportedToEnvironments = await exportLiteToAllEnvironments(process.cwd());
+
+    if (!exportedToEnvironments) {
+      try {
+        const writtenPath = await writeLiteScript(finalPath);
+        console.log(`Successfully exported clawmini-lite to ${writtenPath}`);
+      } catch (err) {
+        console.error(
+          `Failed to export script: ${err instanceof Error ? err.message : String(err)}`
+        );
+        process.exit(1);
+      }
+    }
+  });