clawmini 0.0.1

package/src/shared/event-source.ts

@@ -0,0 +1,121 @@
+import http from 'node:http';
+
+export function createUnixSocketEventSource(socketPath: string) {
+  return class UnixSocketEventSource {
+    public readyState: number = 0; // CONNECTING
+    public readonly CONNECTING = 0;
+    public readonly OPEN = 1;
+    public readonly CLOSED = 2;
+
+    req: http.ClientRequest | null = null;
+    listeners: Record<string, ((event: Record<string, unknown>) => void)[]> = {};
+
+    constructor(url: string, init?: Record<string, unknown>) {
+      const parsedUrl = new URL(url);
+
+      const options: http.RequestOptions = {
+        socketPath,
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: 'GET',
+        headers: {
+          Accept: 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          ...(init?.headers as Record<string, string> | undefined),
+        },
+      };
+
+      this.req = http.request(options, (res) => {
+        if (res.statusCode === 200) {
+          this.readyState = this.OPEN;
+          this.dispatchEvent({ type: 'open' });
+        } else {
+          this.readyState = this.CLOSED;
+          this.dispatchEvent({
+            type: 'error',
+            message: `Unexpected status code: ${res.statusCode}`,
+          });
+          return;
+        }
+
+        let buffer = '';
+        res.on('data', (chunk) => {
+          buffer += chunk.toString('utf-8');
+          const lines = buffer.split(/\r?\n\r?\n/);
+          buffer = lines.pop() || '';
+
+          for (const block of lines) {
+            this.parseBlock(block);
+          }
+        });
+
+        res.on('end', () => {
+          if (buffer) this.parseBlock(buffer);
+          this.readyState = this.CLOSED;
+          this.dispatchEvent({ type: 'close' });
+        });
+      });
+
+      this.req.on('error', (err) => {
+        this.readyState = this.CLOSED;
+        this.dispatchEvent({ type: 'error', error: err });
+      });
+
+      this.req.end();
+    }
+
+    parseBlock(block: string) {
+      if (!block.trim()) return;
+
+      const lines = block.split(/\r?\n/);
+      let eventType = 'message';
+      let data = '';
+      let id = '';
+
+      for (const line of lines) {
+        if (line.startsWith('event: ')) {
+          eventType = line.slice(7).trim();
+        } else if (line.startsWith('data: ')) {
+          data += (data ? '\n' : '') + line.slice(6);
+        } else if (line.startsWith('id: ')) {
+          id = line.slice(4).trim();
+        }
+      }
+
+      if (data) {
+        this.dispatchEvent({
+          type: eventType,
+          data,
+          lastEventId: id,
+        });
+      }
+    }
+
+    public addEventListener(type: string, listener: (event: Record<string, unknown>) => void) {
+      if (!this.listeners[type]) {
+        this.listeners[type] = [];
+      }
+      this.listeners[type].push(listener);
+    }
+
+    public removeEventListener(type: string, listener: (event: Record<string, unknown>) => void) {
+      if (!this.listeners[type]) return;
+      this.listeners[type] = this.listeners[type].filter((l) => l !== listener);
+    }
+
+    dispatchEvent(event: Record<string, unknown>) {
+      const type = event.type as string;
+      if (this.listeners[type]) {
+        for (const listener of this.listeners[type]) {
+          listener(event);
+        }
+      }
+    }
+
+    public close() {
+      this.readyState = this.CLOSED;
+      if (this.req) {
+        this.req.destroy();
+      }
+    }
+  };
+}

package/src/shared/fetch.ts

@@ -0,0 +1,45 @@
+import http from 'node:http';
+
+export function createUnixSocketFetch(socketPath: string) {
+  return async (
+    input: string | URL | globalThis.Request,
+    init?: unknown
+  ): Promise<globalThis.Response> => {
+    const urlString =
+      typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+    const url = new URL(urlString);
+
+    return new Promise((resolve, reject) => {
+      const options: http.RequestOptions = {
+        socketPath,
+        path: url.pathname + url.search,
+        method: (init as globalThis.RequestInit)?.method || 'GET',
+        headers: ((init as globalThis.RequestInit)?.headers as Record<string, string>) || {},
+      };
+
+      const req = http.request(options, (res) => {
+        const chunks: Buffer[] = [];
+        res.on('data', (chunk) => chunks.push(chunk));
+        res.on('end', () => {
+          const body = Buffer.concat(chunks).toString('utf-8');
+
+          const response = new Response(body, {
+            status: res.statusCode || 200,
+            statusText: res.statusMessage || 'OK',
+            headers: new Headers(res.headers as Record<string, string>),
+          });
+
+          resolve(response);
+        });
+        res.on('error', reject);
+      });
+
+      req.on('error', reject);
+
+      if ((init as globalThis.RequestInit)?.body) {
+        req.write((init as globalThis.RequestInit)?.body as string | Buffer | Uint8Array);
+      }
+      req.end();
+    });
+  };
+}

package/src/shared/lite.ts

@@ -0,0 +1,129 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readSettings, readEnvironment, getWorkspaceRoot } from './workspace.js';
+import type { Environment } from './config.js';
+
+export async function getLiteScriptContent(): Promise<string> {
+  let liteScriptContent: string;
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+  let liteScriptPath = path.resolve(__dirname, 'cli/lite.mjs'); // if bundled in a shared chunk at dist/
+
+  try {
+    await fs.access(liteScriptPath);
+  } catch {
+    try {
+      // If bundled in dist/cli or dist/daemon and lite is next to it
+      liteScriptPath = path.resolve(__dirname, 'lite.mjs');
+      await fs.access(liteScriptPath);
+    } catch {
+      try {
+        // If bundled in dist/daemon, it might be in ../cli/lite.mjs
+        liteScriptPath = path.resolve(__dirname, '../cli/lite.mjs');
+        await fs.access(liteScriptPath);
+      } catch {
+        // Fallback for development/testing when running from src/shared
+        liteScriptPath = path.resolve(__dirname, '../../dist/cli/lite.mjs');
+      }
+    }
+  }
+
+  liteScriptContent = await fs.readFile(liteScriptPath, 'utf8');
+
+  // Ensure it has the hashbang (if tsdown stripped it or if missing)
+  if (!liteScriptContent.startsWith('#!')) {
+    liteScriptContent = '#!/usr/bin/env node\n' + liteScriptContent;
+  }
+  return liteScriptContent;
+}
+
+export async function writeLiteScript(outPath: string): Promise<string> {
+  const content = await getLiteScriptContent();
+
+  let finalPath = outPath;
+  const isDir =
+    finalPath.endsWith(path.sep) ||
+    !(
+      path.extname(finalPath) === '.js' ||
+      path.extname(finalPath) === '.mjs' ||
+      path.basename(finalPath) === 'clawmini-lite'
+    );
+
+  try {
+    const stat = await fs.stat(finalPath);
+    if (stat.isDirectory()) {
+      finalPath = path.join(finalPath, 'clawmini-lite.js');
+    }
+  } catch {
+    if (
+      isDir &&
+      !path.extname(finalPath) &&
+      !finalPath.endsWith('clawmini-lite') &&
+      !finalPath.endsWith('clawmini-lite.js')
+    ) {
+      await fs.mkdir(finalPath, { recursive: true });
+      finalPath = path.join(finalPath, 'clawmini-lite.js');
+    }
+  }
+
+  const dir = path.dirname(finalPath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(finalPath, content, { mode: 0o755 });
+  return finalPath;
+}
+
+export async function exportLiteToEnvironment(
+  envName: string,
+  envConfig: Environment,
+  affectedDir: string
+): Promise<boolean> {
+  if (!envConfig?.exportLiteTo) return false;
+
+  const finalExportPath = path.resolve(affectedDir, envConfig.exportLiteTo);
+
+  if (
+    !finalExportPath.startsWith(affectedDir + path.sep) &&
+    finalExportPath !== affectedDir &&
+    !finalExportPath.startsWith(affectedDir + '/')
+  ) {
+    console.warn(
+      `Skipping export for environment '${envName}': exportLiteTo path '${envConfig.exportLiteTo}' escapes the environment target directory '${affectedDir}'`
+    );
+    return false;
+  }
+
+  try {
+    const writtenPath = await writeLiteScript(finalExportPath);
+    console.log(`Successfully exported clawmini-lite to ${writtenPath} (Environment: ${envName})`);
+    return true;
+  } catch (err) {
+    console.error(
+      `Failed to export clawmini-lite to ${finalExportPath} (Environment: ${envName}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  }
+}
+
+export async function exportLiteToAllEnvironments(startDir = process.cwd()): Promise<boolean> {
+  let exportedToEnvironments = false;
+  try {
+    const workspaceRoot = getWorkspaceRoot(startDir);
+    const settings = await readSettings(workspaceRoot);
+    if (settings?.environments) {
+      for (const [envPath, envName] of Object.entries(settings.environments)) {
+        const envConfig = await readEnvironment(envName, workspaceRoot);
+        if (envConfig) {
+          const affectedDir = path.resolve(workspaceRoot, envPath);
+          const exported = await exportLiteToEnvironment(envName, envConfig, affectedDir);
+          if (exported) {
+            exportedToEnvironments = true;
+          }
+        }
+      }
+    }
+  } catch {
+    // Ignore settings read errors
+  }
+  return exportedToEnvironments;
+}

package/src/shared/policies.ts

@@ -0,0 +1,24 @@
+export interface PolicyDefinition {
+  description?: string;
+  command: string;
+  args?: string[];
+  allowHelp?: boolean;
+}
+
+export interface PolicyConfig {
+  policies: Record<string, PolicyDefinition>;
+}
+
+export type RequestState = 'Pending' | 'Approved' | 'Rejected';
+
+export interface PolicyRequest {
+  id: string;
+  commandName: string;
+  args: string[];
+  fileMappings: Record<string, string>;
+  state: RequestState;
+  createdAt: number;
+  rejectionReason?: string;
+  chatId: string;
+  agentId: string;
+}

package/src/shared/utils/env.ts

@@ -0,0 +1,27 @@
+export function applyEnvOverrides(
+  targetEnv: Record<string, string>,
+  overrides?: Record<string, string | boolean>
+): void {
+  if (!overrides) return;
+
+  for (const [key, val] of Object.entries(overrides)) {
+    if (val === true && process.env[key] !== undefined) {
+      targetEnv[key] = process.env[key];
+    } else if (typeof val === 'string') {
+      targetEnv[key] = val;
+    }
+  }
+}
+
+export function getActiveEnvKeys(
+  ...envs: (Record<string, string | boolean> | undefined)[]
+): Set<string> {
+  const keys = new Set<string>();
+  for (const env of envs) {
+    if (!env) continue;
+    Object.entries(env).forEach(([key, val]) => {
+      if (val === true || typeof val === 'string') keys.add(key);
+    });
+  }
+  return keys;
+}

package/src/shared/utils/fs.ts

@@ -0,0 +1,13 @@
+import { sep } from 'node:path';
+
+export function pathIsInsideDir(
+  path: string,
+  dir: string,
+  { allowSameDir = false }: { allowSameDir?: boolean } = {}
+): boolean {
+  const dirWithSep = dir.endsWith(sep) ? dir : dir + sep;
+  if (allowSameDir && path === dir) {
+    return true;
+  }
+  return path.startsWith(dirWithSep) && path !== dir;
+}