clawless 0.1.2

package/bin/cli.ts

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+
+const ENV_KEY_MAP: Record<string, string> = {
+	telegramToken: 'TELEGRAM_TOKEN',
+	typingIntervalMs: 'TYPING_INTERVAL_MS',
+	geminiCommand: 'GEMINI_COMMAND',
+	geminiApprovalMode: 'GEMINI_APPROVAL_MODE',
+	geminiModel: 'GEMINI_MODEL',
+	acpPermissionStrategy: 'ACP_PERMISSION_STRATEGY',
+	geminiTimeoutMs: 'GEMINI_TIMEOUT_MS',
+	geminiNoOutputTimeoutMs: 'GEMINI_NO_OUTPUT_TIMEOUT_MS',
+	geminiKillGraceMs: 'GEMINI_KILL_GRACE_MS',
+	maxResponseLength: 'MAX_RESPONSE_LENGTH',
+	acpStreamStdout: 'ACP_STREAM_STDOUT',
+	acpDebugStream: 'ACP_DEBUG_STREAM',
+	heartbeatIntervalMs: 'HEARTBEAT_INTERVAL_MS',
+	callbackHost: 'CALLBACK_HOST',
+	callbackPort: 'CALLBACK_PORT',
+	callbackAuthToken: 'CALLBACK_AUTH_TOKEN',
+	callbackMaxBodyBytes: 'CALLBACK_MAX_BODY_BYTES',
+	agentBridgeHome: 'AGENT_BRIDGE_HOME',
+	memoryFilePath: 'MEMORY_FILE_PATH',
+	memoryMaxChars: 'MEMORY_MAX_CHARS',
+	schedulesFilePath: 'SCHEDULES_FILE_PATH',
+};
+
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.clawless', 'config.json');
+const DEFAULT_AGENT_BRIDGE_HOME = path.join(os.homedir(), '.clawless');
+const DEFAULT_MEMORY_FILE_PATH = path.join(DEFAULT_AGENT_BRIDGE_HOME, 'MEMORY.md');
+const DEFAULT_CONFIG_TEMPLATE = {
+	telegramToken: 'your_telegram_bot_token_here',
+	typingIntervalMs: 4000,
+	geminiCommand: 'gemini',
+	geminiApprovalMode: 'yolo',
+	geminiModel: '',
+	acpPermissionStrategy: 'allow_once',
+	geminiTimeoutMs: 900000,
+	geminiNoOutputTimeoutMs: 60000,
+	geminiKillGraceMs: 5000,
+	maxResponseLength: 4000,
+	acpStreamStdout: false,
+	acpDebugStream: false,
+	heartbeatIntervalMs: 60000,
+	callbackHost: 'localhost',
+	callbackPort: 8788,
+	callbackAuthToken: '',
+	callbackMaxBodyBytes: 65536,
+	agentBridgeHome: '~/.clawless',
+	memoryFilePath: '~/.clawless/MEMORY.md',
+	memoryMaxChars: 12000,
+	schedulesFilePath: '~/.clawless/schedules.json',
+};
+
+function printHelp() {
+	console.log(`clawless
+
+Usage:
+	clawless [--config <path>]
+
+Options:
+	--config <path>   Path to JSON config file (default: ~/.clawless/config.json)
+	-h, --help        Show this help message
+
+Config precedence:
+	1) Existing environment variables
+	2) Values from config file
+`);
+}
+
+function parseArgs(argv: string[]) {
+	const result = {
+		configPath: process.env.GEMINI_BRIDGE_CONFIG || process.env.AGENT_BRIDGE_CONFIG || DEFAULT_CONFIG_PATH,
+		help: false,
+	};
+
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+
+		if (arg === '-h' || arg === '--help') {
+			result.help = true;
+			continue;
+		}
+
+		if (arg === '--config') {
+			const value = argv[index + 1];
+			if (!value) {
+				throw new Error('--config requires a file path');
+			}
+			result.configPath = value;
+			index += 1;
+			continue;
+		}
+
+		throw new Error(`Unknown argument: ${arg}`);
+	}
+
+	return result;
+}
+
+function toEnvValue(value: unknown) {
+	if (value === null || value === undefined) {
+		return undefined;
+	}
+	if (typeof value === 'string') {
+		return value;
+	}
+	return String(value);
+}
+
+function resolveEnvKey(configKey: string) {
+	if (configKey in ENV_KEY_MAP) {
+		return ENV_KEY_MAP[configKey];
+	}
+
+	const looksLikeEnvKey = /^[A-Z0-9_]+$/.test(configKey);
+	if (looksLikeEnvKey) {
+		return configKey;
+	}
+
+	return null;
+}
+
+function applyConfigToEnv(configData: Record<string, unknown>) {
+	if (!configData || typeof configData !== 'object' || Array.isArray(configData)) {
+		throw new Error('Config file must contain a JSON object at the top level');
+	}
+
+	for (const [configKey, rawValue] of Object.entries(configData)) {
+		const envKey = resolveEnvKey(configKey);
+		if (!envKey) {
+			continue;
+		}
+
+		if (process.env[envKey] !== undefined) {
+			continue;
+		}
+
+		const envValue = toEnvValue(rawValue);
+		if (envValue !== undefined) {
+			process.env[envKey] = envValue;
+		}
+	}
+}
+
+function resolveConfigPath(configPath: string) {
+	if (!configPath || configPath === '~') {
+		return os.homedir();
+	}
+
+	if (configPath.startsWith('~/')) {
+		return path.join(os.homedir(), configPath.slice(2));
+	}
+
+	return path.resolve(process.cwd(), configPath);
+}
+
+function ensureConfigFile(configPath: string) {
+	const absolutePath = resolveConfigPath(configPath);
+	if (fs.existsSync(absolutePath)) {
+		return { created: false, path: absolutePath };
+	}
+
+	fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+	fs.writeFileSync(absolutePath, `${JSON.stringify(DEFAULT_CONFIG_TEMPLATE, null, 2)}\n`, 'utf8');
+	return { created: true, path: absolutePath };
+}
+
+function ensureMemoryFile(memoryFilePath: string) {
+	const absolutePath = resolveConfigPath(memoryFilePath);
+	if (!fs.existsSync(absolutePath)) {
+		fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+		const template = [
+			'# Clawless Memory',
+			'',
+			'This file stores durable memory notes for Clawless.',
+			'',
+			'## Notes',
+			'',
+		].join('\n');
+		fs.writeFileSync(absolutePath, `${template}\n`, 'utf8');
+		return { created: true, path: absolutePath };
+	}
+
+	return { created: false, path: absolutePath };
+}
+
+function ensureMemoryFromEnv() {
+	const configuredHome = process.env.AGENT_BRIDGE_HOME || DEFAULT_AGENT_BRIDGE_HOME;
+	const configuredMemoryPath = process.env.MEMORY_FILE_PATH || path.join(configuredHome, 'MEMORY.md');
+
+	if (!process.env.AGENT_BRIDGE_HOME) {
+		process.env.AGENT_BRIDGE_HOME = configuredHome;
+	}
+
+	if (!process.env.MEMORY_FILE_PATH) {
+		process.env.MEMORY_FILE_PATH = configuredMemoryPath;
+	}
+
+	return ensureMemoryFile(process.env.MEMORY_FILE_PATH || DEFAULT_MEMORY_FILE_PATH);
+}
+
+function logMemoryFileCreation(memoryState: { created: boolean; path: string }) {
+	if (memoryState.created) {
+		console.log(`[clawless] Created memory file: ${memoryState.path}`);
+	}
+}
+
+function loadConfigFile(configPath: string) {
+	const absolutePath = resolveConfigPath(configPath);
+	if (!fs.existsSync(absolutePath)) {
+		return null;
+	}
+
+	const fileContent = fs.readFileSync(absolutePath, 'utf8');
+	const parsed = JSON.parse(fileContent);
+	applyConfigToEnv(parsed);
+	return absolutePath;
+}
+
+try {
+	const args = parseArgs(process.argv.slice(2));
+
+	if (args.help) {
+		printHelp();
+		process.exit(0);
+	}
+
+	const configState = ensureConfigFile(args.configPath);
+	const memoryState = ensureMemoryFromEnv();
+	logMemoryFileCreation(memoryState);
+
+	if (configState.created) {
+		console.log(`[clawless] Created config template: ${configState.path}`);
+		console.log('[clawless] Fill in placeholder values, then run clawless again.');
+		process.exit(0);
+	}
+
+	const loadedConfigPath = loadConfigFile(args.configPath);
+	if (loadedConfigPath) {
+		console.log(`[clawless] Loaded config: ${loadedConfigPath}`);
+	}
+
+	const postConfigMemoryState = ensureMemoryFromEnv();
+	logMemoryFileCreation(postConfigMemoryState);
+
+	await import('../index.js');
+} catch (error: any) {
+	console.error(`[clawless] ${error.message}`);
+	process.exit(1);
+}

package/dist/acp/clientHelpers.js

@@ -0,0 +1,19 @@
+export function buildPermissionResponse(options, permissionStrategy) {
+    if (!Array.isArray(options) || options.length === 0) {
+        return { outcome: { outcome: 'cancelled' } };
+    }
+    if (permissionStrategy === 'cancelled') {
+        return { outcome: { outcome: 'cancelled' } };
+    }
+    const preferred = options.find((option) => option.kind === permissionStrategy);
+    const selectedOption = preferred || options[0];
+    return {
+        outcome: {
+            outcome: 'selected',
+            optionId: selectedOption.optionId,
+        },
+    };
+}
+export async function noOpAcpFileOperation(_params) {
+    return {};
+}

package/dist/acp/tempAcpRunner.js

@@ -0,0 +1,263 @@
+import { spawn } from 'node:child_process';
+import { Readable, Writable } from 'node:stream';
+import * as acp from '@agentclientprotocol/sdk';
+import { buildPermissionResponse, noOpAcpFileOperation } from './clientHelpers.js';
+import { getErrorMessage } from '../utils/error.js';
+const ACP_DEBUG_STREAM = String(process.env.ACP_DEBUG_STREAM || '').toLowerCase() === 'true';
+const GEMINI_KILL_GRACE_MS = parseInt(process.env.GEMINI_KILL_GRACE_MS || '5000', 10);
+export async function runPromptWithTempAcp(options) {
+    const { scheduleId, promptForGemini, command, args, cwd, timeoutMs, noOutputTimeoutMs, permissionStrategy, stderrTailMaxChars = 4000, logInfo, } = options;
+    const tempProcess = spawn(command, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd,
+    });
+    logInfo('Scheduler temp Gemini ACP process started', {
+        scheduleId,
+        pid: tempProcess.pid,
+        command,
+        args,
+    });
+    let tempConnection = null;
+    let tempSessionId = null;
+    let tempCollector = null;
+    let tempStderrTail = '';
+    let noOutputTimeout = null;
+    let overallTimeout = null;
+    let cleanedUp = false;
+    const terminateProcessGracefully = () => {
+        return new Promise((resolve) => {
+            if (!tempProcess || tempProcess.killed || tempProcess.exitCode !== null) {
+                resolve();
+                return;
+            }
+            let settled = false;
+            const finalize = (reason) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                logInfo('Scheduler temp Gemini process termination finalized', {
+                    scheduleId,
+                    pid: tempProcess.pid,
+                    reason,
+                });
+                resolve();
+            };
+            tempProcess.once('exit', () => finalize('exit'));
+            logInfo('Scheduler temp Gemini process SIGTERM', {
+                scheduleId,
+                pid: tempProcess.pid,
+                graceMs: GEMINI_KILL_GRACE_MS,
+            });
+            tempProcess.kill('SIGTERM');
+            setTimeout(() => {
+                if (settled || tempProcess.killed || tempProcess.exitCode !== null) {
+                    finalize('already-exited');
+                    return;
+                }
+                logInfo('Scheduler temp Gemini process SIGKILL escalation', {
+                    scheduleId,
+                    pid: tempProcess.pid,
+                });
+                tempProcess.kill('SIGKILL');
+                finalize('sigkill');
+            }, Math.max(0, GEMINI_KILL_GRACE_MS));
+        });
+    };
+    const appendTempStderrTail = (text) => {
+        tempStderrTail = `${tempStderrTail}${text}`;
+        if (tempStderrTail.length > stderrTailMaxChars) {
+            tempStderrTail = tempStderrTail.slice(-stderrTailMaxChars);
+        }
+    };
+    const clearTimers = () => {
+        if (noOutputTimeout) {
+            clearTimeout(noOutputTimeout);
+            noOutputTimeout = null;
+        }
+        if (overallTimeout) {
+            clearTimeout(overallTimeout);
+            overallTimeout = null;
+        }
+    };
+    const cleanup = async () => {
+        if (cleanedUp) {
+            return;
+        }
+        cleanedUp = true;
+        clearTimers();
+        try {
+            if (tempConnection && tempSessionId) {
+                await tempConnection.cancel({ sessionId: tempSessionId });
+            }
+        }
+        catch (_) {
+        }
+        if (!tempProcess.killed && tempProcess.exitCode === null) {
+            await terminateProcessGracefully();
+        }
+        logInfo('Scheduler temp Gemini ACP process cleanup complete', {
+            scheduleId,
+            pid: tempProcess.pid,
+        });
+    };
+    tempProcess.stderr.on('data', (chunk) => {
+        const rawText = chunk.toString();
+        appendTempStderrTail(rawText);
+        const text = rawText.trim();
+        if (text) {
+            console.error(`[gemini:scheduler:${scheduleId}] ${text}`);
+        }
+        tempCollector?.onActivity();
+    });
+    tempProcess.on('error', (error) => {
+        logInfo('Scheduler temp Gemini ACP process error', {
+            scheduleId,
+            pid: tempProcess.pid,
+            error: error.message,
+        });
+    });
+    tempProcess.on('close', (code, signal) => {
+        logInfo('Scheduler temp Gemini ACP process exited', {
+            scheduleId,
+            pid: tempProcess.pid,
+            code,
+            signal,
+        });
+    });
+    try {
+        const input = Writable.toWeb(tempProcess.stdin);
+        const output = Readable.toWeb(tempProcess.stdout);
+        const stream = acp.ndJsonStream(input, output);
+        const tempClient = {
+            async requestPermission(params) {
+                return buildPermissionResponse(params?.options, permissionStrategy);
+            },
+            async sessionUpdate(params) {
+                if (!tempCollector || params.sessionId !== tempSessionId) {
+                    return;
+                }
+                tempCollector.onActivity();
+                if (params.update?.sessionUpdate === 'agent_message_chunk' && params.update?.content?.type === 'text') {
+                    const chunkText = params.update.content.text;
+                    tempCollector.append(chunkText);
+                }
+            },
+            async readTextFile(_params) {
+                return noOpAcpFileOperation(_params);
+            },
+            async writeTextFile(_params) {
+                return noOpAcpFileOperation(_params);
+            },
+        };
+        tempConnection = new acp.ClientSideConnection(() => tempClient, stream);
+        await tempConnection.initialize({
+            protocolVersion: acp.PROTOCOL_VERSION,
+            clientCapabilities: {},
+        });
+        const session = await tempConnection.newSession({
+            cwd,
+            mcpServers: [],
+        });
+        tempSessionId = session.sessionId;
+        return await new Promise((resolve, reject) => {
+            let response = '';
+            let settled = false;
+            const startedAt = Date.now();
+            let chunkCount = 0;
+            let firstChunkAt = null;
+            const settle = async (handler) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                await cleanup();
+                handler();
+            };
+            const refreshNoOutputTimer = () => {
+                if (!noOutputTimeoutMs || noOutputTimeoutMs <= 0) {
+                    return;
+                }
+                if (noOutputTimeout) {
+                    clearTimeout(noOutputTimeout);
+                }
+                noOutputTimeout = setTimeout(async () => {
+                    try {
+                        if (tempConnection && tempSessionId) {
+                            await tempConnection.cancel({ sessionId: tempSessionId });
+                        }
+                    }
+                    catch (_) {
+                    }
+                    await settle(() => reject(new Error(`Scheduler Gemini ACP produced no output for ${noOutputTimeoutMs}ms`)));
+                }, noOutputTimeoutMs);
+            };
+            overallTimeout = setTimeout(async () => {
+                try {
+                    if (tempConnection && tempSessionId) {
+                        await tempConnection.cancel({ sessionId: tempSessionId });
+                    }
+                }
+                catch (_) {
+                }
+                await settle(() => reject(new Error(`Scheduler Gemini ACP timed out after ${timeoutMs}ms`)));
+            }, timeoutMs);
+            tempCollector = {
+                onActivity: refreshNoOutputTimer,
+                append: (chunk) => {
+                    refreshNoOutputTimer();
+                    chunkCount += 1;
+                    if (!firstChunkAt) {
+                        firstChunkAt = Date.now();
+                    }
+                    if (ACP_DEBUG_STREAM) {
+                        logInfo('Scheduler ACP chunk received', {
+                            scheduleId,
+                            chunkIndex: chunkCount,
+                            chunkLength: chunk.length,
+                            elapsedMs: Date.now() - startedAt,
+                            bufferLengthBeforeAppend: response.length,
+                        });
+                    }
+                    response += chunk;
+                },
+            };
+            refreshNoOutputTimer();
+            tempConnection.prompt({
+                sessionId: tempSessionId,
+                prompt: [{ type: 'text', text: promptForGemini }],
+            })
+                .then(async (result) => {
+                if (ACP_DEBUG_STREAM) {
+                    logInfo('Scheduler ACP prompt stop reason', {
+                        scheduleId,
+                        stopReason: result?.stopReason || '(none)',
+                        chunkCount,
+                        firstChunkDelayMs: firstChunkAt ? firstChunkAt - startedAt : null,
+                        elapsedMs: Date.now() - startedAt,
+                        bufferedLength: response.length,
+                    });
+                }
+                if (result?.stopReason === 'cancelled' && !response) {
+                    await settle(() => reject(new Error('Scheduler Gemini ACP prompt was cancelled')));
+                    return;
+                }
+                await settle(() => resolve(response || 'No response received.'));
+            })
+                .catch(async (error) => {
+                await settle(() => reject(new Error(error?.message || 'Scheduler Gemini ACP prompt failed')));
+            });
+        });
+    }
+    catch (error) {
+        logInfo('Scheduler temporary Gemini ACP run failed', {
+            scheduleId,
+            error: getErrorMessage(error),
+            stderrTail: tempStderrTail || '(empty)',
+        });
+        throw error;
+    }
+    finally {
+        await cleanup();
+    }
+}