@fonz/tgcc 0.0.1 → 0.2.0

package/dist/cli.js

@@ -0,0 +1,668 @@
+#!/usr/bin/env node
+import { createConnection } from 'node:net';
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { loadConfig, agentForRepo, CONFIG_PATH, updateConfig, isValidRepoName, findRepoOwner } from './config.js';
+const CTL_DIR = '/tmp/tgcc/ctl';
+// ── Socket communication ──
+function sendRequest(socketPath, request) {
+    return new Promise((resolve, reject) => {
+        if (!existsSync(socketPath)) {
+            reject(new Error(`Agent socket not found: ${socketPath}\nIs the TGCC service running?`));
+            return;
+        }
+        const socket = createConnection(socketPath);
+        let buffer = '';
+        socket.on('connect', () => {
+            socket.write(JSON.stringify(request) + '\n');
+        });
+        socket.on('data', (data) => {
+            buffer += data.toString();
+            const newlineIdx = buffer.indexOf('\n');
+            if (newlineIdx !== -1) {
+                const line = buffer.slice(0, newlineIdx);
+                try {
+                    const response = JSON.parse(line);
+                    socket.destroy();
+                    resolve(response);
+                }
+                catch (err) {
+                    socket.destroy();
+                    reject(new Error(`Invalid response from agent: ${line}`));
+                }
+            }
+        });
+        socket.on('error', (err) => {
+            reject(new Error(`Cannot connect to agent: ${err.message}`));
+        });
+        // Timeout after 10s
+        socket.setTimeout(10_000, () => {
+            socket.destroy();
+            reject(new Error('Connection timed out'));
+        });
+    });
+}
+// ── Agent resolution ──
+function resolveAgent(explicitAgent, config) {
+    if (explicitAgent) {
+        if (!config.agents[explicitAgent]) {
+            console.error(`Error: Unknown agent "${explicitAgent}"`);
+            process.exit(1);
+        }
+        return explicitAgent;
+    }
+    // Auto-detect from cwd
+    const cwd = process.cwd();
+    const agentId = agentForRepo(config, cwd);
+    if (!agentId) {
+        console.error(`Error: No agent configured for this repo (${cwd})`);
+        console.error('Use --agent <name> to specify explicitly');
+        process.exit(1);
+    }
+    return agentId;
+}
+// ── Commands ──
+async function cmdMessage(args) {
+    let agentName;
+    let sessionId;
+    const textParts = [];
+    // Parse flags
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--agent' && i + 1 < args.length) {
+            agentName = args[++i];
+        }
+        else if (args[i] === '--session' && i + 1 < args.length) {
+            sessionId = args[++i];
+        }
+        else {
+            textParts.push(args[i]);
+        }
+    }
+    const text = textParts.join(' ');
+    if (!text) {
+        console.error('Error: No message text provided');
+        console.error('Usage: tgcc message [--agent <name>] [--session <id>] "your message"');
+        process.exit(1);
+    }
+    const config = loadConfigSafe();
+    const agentId = resolveAgent(agentName, config);
+    const socketPath = join(CTL_DIR, `${agentId}.sock`);
+    const request = {
+        type: 'message',
+        text,
+        agent: agentId,
+        ...(sessionId ? { session: sessionId } : {}),
+    };
+    const response = await sendRequest(socketPath, request);
+    if (response.type === 'error') {
+        console.error(`Error: ${response.message}`);
+        process.exit(1);
+    }
+    if (response.type === 'ack') {
+        console.log(`Message sent to ${agentId}`);
+        console.log(`  Session: ${response.sessionId?.slice(0, 8) ?? 'pending'}`);
+        console.log(`  State: ${response.state}`);
+    }
+}
+async function cmdStatus(args) {
+    let agentName;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--agent' && i + 1 < args.length) {
+            agentName = args[++i];
+        }
+    }
+    // If no explicit agent and we can detect from cwd, use it
+    const config = loadConfigSafe();
+    // Find which sockets exist (running agents)
+    const sockets = existsSync(CTL_DIR)
+        ? readdirSync(CTL_DIR).filter(f => f.endsWith('.sock'))
+        : [];
+    if (sockets.length === 0) {
+        console.log('No running agents found.');
+        return;
+    }
+    // If specific agent requested, only query that one
+    const targetAgents = agentName ? [`${agentName}.sock`] : sockets;
+    for (const sockFile of targetAgents) {
+        const socketPath = join(CTL_DIR, sockFile);
+        if (!existsSync(socketPath)) {
+            console.log(`Agent ${sockFile.replace('.sock', '')}: not running`);
+            continue;
+        }
+        try {
+            const response = await sendRequest(socketPath, {
+                type: 'status',
+                agent: sockFile.replace('.sock', ''),
+            });
+            if (response.type === 'status') {
+                for (const agent of response.agents) {
+                    console.log(`\n${agent.id}:`);
+                    console.log(`  State: ${agent.state}`);
+                    console.log(`  Session: ${agent.sessionId?.slice(0, 8) ?? 'none'}`);
+                    console.log(`  Repo: ${agent.repo}`);
+                }
+                if (response.sessions.length > 0) {
+                    console.log('\n  Recent sessions:');
+                    for (const sess of response.sessions) {
+                        console.log(`    ${sess.id.slice(0, 8)} — ${sess.messageCount} msgs, $${sess.totalCostUsd.toFixed(4)}`);
+                    }
+                }
+            }
+            else if (response.type === 'error') {
+                console.error(`  Error: ${response.message}`);
+            }
+        }
+        catch (err) {
+            console.error(`  ${err instanceof Error ? err.message : err}`);
+        }
+    }
+}
+function loadConfigSafe() {
+    try {
+        return loadConfig();
+    }
+    catch (err) {
+        console.error(`Error loading config: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+}
+// ── Raw config read/write (preserves structure for agent management) ──
+function readRawConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        return { agents: {} };
+    }
+    return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+}
+function writeRawConfig(raw) {
+    const dir = dirname(CONFIG_PATH);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(raw, null, 2) + '\n');
+}
+// ── Agent management commands ──
+function cmdAgentAdd(args) {
+    const name = args[0];
+    if (!name) {
+        console.error('Usage: tgcc agent add <name> --bot-token <token> [--repo <name-or-path>]');
+        process.exit(1);
+    }
+    let botToken;
+    let repo;
+    for (let i = 1; i < args.length; i++) {
+        if ((args[i] === '--bot-token' || args[i] === '--token') && i + 1 < args.length) {
+            botToken = args[++i];
+        }
+        else if (args[i] === '--repo' && i + 1 < args.length) {
+            repo = args[++i];
+        }
+    }
+    if (!botToken) {
+        console.error('Error: --bot-token is required');
+        process.exit(1);
+    }
+    const raw = readRawConfig();
+    const agents = (raw.agents ?? {});
+    if (agents[name]) {
+        console.error(`Error: Agent "${name}" already exists. Remove it first.`);
+        process.exit(1);
+    }
+    const agentEntry = {
+        botToken,
+        allowedUsers: ['7016073156'], // default — user can edit config
+    };
+    if (repo) {
+        // Check if it's a registry key or a path
+        const repos = (raw.repos ?? {});
+        if (repos[repo]) {
+            agentEntry.defaults = { repo };
+        }
+        else {
+            // It's a direct path — add to repos registry and reference it
+            const repoName = repo.split('/').pop() ?? name;
+            const absPath = resolve(repo);
+            repos[repoName] = absPath;
+            raw.repos = repos;
+            agentEntry.defaults = { repo: repoName };
+        }
+    }
+    agents[name] = agentEntry;
+    raw.agents = agents;
+    writeRawConfig(raw);
+    console.log(`Agent "${name}" added.`);
+    if (repo)
+        console.log(`  Default repo: ${repo}`);
+    console.log('Config hot-reload will pick it up automatically.');
+}
+function cmdAgentRemove(args) {
+    const name = args[0];
+    if (!name) {
+        console.error('Usage: tgcc agent remove <name>');
+        process.exit(1);
+    }
+    const raw = readRawConfig();
+    const agents = (raw.agents ?? {});
+    if (!agents[name]) {
+        console.error(`Error: Agent "${name}" not found.`);
+        process.exit(1);
+    }
+    delete agents[name];
+    raw.agents = agents;
+    writeRawConfig(raw);
+    console.log(`Agent "${name}" removed.`);
+}
+function cmdAgentList() {
+    const raw = readRawConfig();
+    const agents = (raw.agents ?? {});
+    const repos = (raw.repos ?? {});
+    const entries = Object.entries(agents);
+    if (entries.length === 0) {
+        console.log('No agents configured.');
+        return;
+    }
+    for (const [name, agent] of entries) {
+        const defaults = (agent.defaults ?? {});
+        const repoKey = defaults.repo;
+        const repoPath = repoKey ? (repos[repoKey] ?? repoKey) : 'none (generic)';
+        console.log(`${name}:`);
+        console.log(`  Token: ${agent.botToken?.slice(0, 10)}...`);
+        console.log(`  Repo: ${repoPath}`);
+        console.log(`  Users: ${agent.allowedUsers?.join(', ') ?? 'none'}`);
+    }
+}
+function cmdAgentRepo(args) {
+    const name = args[0];
+    const repoArg = args[1];
+    if (!name || !repoArg) {
+        console.error('Usage: tgcc agent repo <name> <name-or-path>');
+        process.exit(1);
+    }
+    const raw = readRawConfig();
+    const agents = (raw.agents ?? {});
+    if (!agents[name]) {
+        console.error(`Error: Agent "${name}" not found.`);
+        process.exit(1);
+    }
+    const repos = (raw.repos ?? {});
+    if (repos[repoArg]) {
+        // It's a registry key
+        const defaults = (agents[name].defaults ?? {});
+        defaults.repo = repoArg;
+        agents[name].defaults = defaults;
+    }
+    else {
+        // Direct path — add to registry
+        const repoName = repoArg.split('/').pop() ?? name;
+        const absPath = resolve(repoArg);
+        repos[repoName] = absPath;
+        raw.repos = repos;
+        const defaults = (agents[name].defaults ?? {});
+        defaults.repo = repoName;
+        agents[name].defaults = defaults;
+    }
+    raw.agents = agents;
+    writeRawConfig(raw);
+    console.log(`Agent "${name}" repo set to "${repoArg}".`);
+}
+function cmdAgentRename(args) {
+    const oldName = args[0];
+    const newName = args[1];
+    if (!oldName || !newName) {
+        console.error('Usage: tgcc agent rename <old-name> <new-name>');
+        process.exit(1);
+    }
+    const raw = readRawConfig();
+    const agents = (raw.agents ?? {});
+    if (!agents[oldName]) {
+        console.error(`Error: Agent "${oldName}" not found.`);
+        process.exit(1);
+    }
+    if (agents[newName]) {
+        console.error(`Error: Agent "${newName}" already exists.`);
+        process.exit(1);
+    }
+    // Move agent config to new key
+    agents[newName] = agents[oldName];
+    delete agents[oldName];
+    raw.agents = agents;
+    writeRawConfig(raw);
+    // Update session state file (rename agent key if present)
+    const globalRaw = (raw.global ?? {});
+    const stateFile = globalRaw.stateFile ?? join(homedir(), '.tgcc', 'state.json');
+    if (existsSync(stateFile)) {
+        try {
+            const state = JSON.parse(readFileSync(stateFile, 'utf-8'));
+            if (state.agents && state.agents[oldName]) {
+                state.agents[newName] = state.agents[oldName];
+                delete state.agents[oldName];
+                writeFileSync(stateFile, JSON.stringify(state, null, 2));
+            }
+        }
+        catch (err) {
+            console.warn(`Warning: Could not update state file: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    console.log(`Agent "${oldName}" renamed to "${newName}".`);
+}
+function cmdAgent(args) {
+    const subcommand = args[0];
+    switch (subcommand) {
+        case 'add':
+            cmdAgentAdd(args.slice(1));
+            break;
+        case 'remove':
+        case 'rm':
+            cmdAgentRemove(args.slice(1));
+            break;
+        case 'rename':
+        case 'mv':
+            cmdAgentRename(args.slice(1));
+            break;
+        case 'list':
+        case 'ls':
+            cmdAgentList();
+            break;
+        case 'repo':
+            cmdAgentRepo(args.slice(1));
+            break;
+        default:
+            console.error('Usage: tgcc agent <add|remove|rename|list|repo>');
+            console.error('');
+            console.error('  add <name> --bot-token <token> [--repo <path>]');
+            console.error('  remove <name>');
+            console.error('  rename <old> <new>');
+            console.error('  list');
+            console.error('  repo <name> <path>');
+            process.exit(1);
+    }
+}
+// ── Repo management commands ──
+function cmdRepoList() {
+    const raw = readRawConfig();
+    const repos = (raw.repos ?? {});
+    const entries = Object.entries(repos);
+    if (entries.length === 0) {
+        console.log('No repos registered.');
+        return;
+    }
+    for (const [name, path] of entries) {
+        const owner = findRepoOwner(raw, name);
+        console.log(`${name}:`);
+        console.log(`  Path: ${path}`);
+        console.log(`  Agent: ${owner ?? 'unassigned'}`);
+    }
+}
+function cmdRepoAdd(args) {
+    const name = args[0];
+    const repoPath = args[1];
+    if (!name || !repoPath) {
+        console.error('Usage: tgcc repo add <name> <path>');
+        process.exit(1);
+    }
+    if (!isValidRepoName(name)) {
+        console.error('Invalid repo name. Use alphanumeric + hyphens only (must start with alphanumeric).');
+        process.exit(1);
+    }
+    if (!existsSync(repoPath)) {
+        console.error(`Path not found: ${repoPath}`);
+        process.exit(1);
+    }
+    const raw = readRawConfig();
+    const repos = (raw.repos ?? {});
+    if (repos[name]) {
+        console.error(`Repo "${name}" already exists.`);
+        process.exit(1);
+    }
+    const absPath = resolve(repoPath);
+    updateConfig((cfg) => {
+        const r = (cfg.repos ?? {});
+        r[name] = absPath;
+        cfg.repos = r;
+    });
+    console.log(`Repo "${name}" added → ${absPath}`);
+}
+function cmdRepoRemove(args) {
+    const name = args[0];
+    if (!name) {
+        console.error('Usage: tgcc repo remove <name>');
+        process.exit(1);
+    }
+    const raw = readRawConfig();
+    const repos = (raw.repos ?? {});
+    if (!repos[name]) {
+        console.error(`Repo "${name}" not found.`);
+        process.exit(1);
+    }
+    const owner = findRepoOwner(raw, name);
+    if (owner) {
+        console.error(`Can't remove: repo "${name}" is assigned to agent "${owner}". Use "tgcc repo clear ${owner}" first.`);
+        process.exit(1);
+    }
+    updateConfig((cfg) => {
+        const r = (cfg.repos ?? {});
+        delete r[name];
+        cfg.repos = r;
+    });
+    console.log(`Repo "${name}" removed.`);
+}
+function cmdRepoAssign(args) {
+    const agentName = args[0];
+    const repoName = args[1];
+    if (!agentName || !repoName) {
+        console.error('Usage: tgcc repo assign <agent> <name>');
+        process.exit(1);
+    }
+    const raw = readRawConfig();
+    const repos = (raw.repos ?? {});
+    const agents = (raw.agents ?? {});
+    if (!repos[repoName]) {
+        console.error(`Repo "${repoName}" not found in registry.`);
+        process.exit(1);
+    }
+    if (!agents[agentName]) {
+        console.error(`Agent "${agentName}" not found.`);
+        process.exit(1);
+    }
+    const existingOwner = findRepoOwner(raw, repoName);
+    if (existingOwner && existingOwner !== agentName) {
+        console.error(`Repo "${repoName}" is already assigned to agent "${existingOwner}".`);
+        process.exit(1);
+    }
+    updateConfig((cfg) => {
+        const a = (cfg.agents ?? {});
+        const agentCfg = a[agentName];
+        if (agentCfg) {
+            const defaults = (agentCfg.defaults ?? {});
+            defaults.repo = repoName;
+            agentCfg.defaults = defaults;
+        }
+    });
+    console.log(`Repo "${repoName}" assigned to agent "${agentName}".`);
+}
+function cmdRepoClear(args) {
+    const agentName = args[0];
+    if (!agentName) {
+        console.error('Usage: tgcc repo clear <agent>');
+        process.exit(1);
+    }
+    const raw = readRawConfig();
+    const agents = (raw.agents ?? {});
+    if (!agents[agentName]) {
+        console.error(`Agent "${agentName}" not found.`);
+        process.exit(1);
+    }
+    updateConfig((cfg) => {
+        const a = (cfg.agents ?? {});
+        const agentCfg = a[agentName];
+        if (agentCfg) {
+            const defaults = (agentCfg.defaults ?? {});
+            delete defaults.repo;
+            agentCfg.defaults = defaults;
+        }
+    });
+    console.log(`Default repo cleared for agent "${agentName}".`);
+}
+function cmdRepo(args) {
+    const subcommand = args[0];
+    switch (subcommand) {
+        case 'add':
+            cmdRepoAdd(args.slice(1));
+            break;
+        case 'remove':
+        case 'rm':
+            cmdRepoRemove(args.slice(1));
+            break;
+        case 'assign':
+            cmdRepoAssign(args.slice(1));
+            break;
+        case 'clear':
+            cmdRepoClear(args.slice(1));
+            break;
+        case undefined:
+        case 'list':
+        case 'ls':
+            cmdRepoList();
+            break;
+        default:
+            console.error('Usage: tgcc repo [add|remove|assign|clear|list]');
+            console.error('');
+            console.error('  (no args)                  List all repos');
+            console.error('  add <name> <path>          Register a repo');
+            console.error('  remove <name>              Remove a repo');
+            console.error('  assign <agent> <name>      Set agent default repo');
+            console.error('  clear <agent>              Clear agent default repo');
+            process.exit(1);
+    }
+}
+// ── Permissions management commands ──
+function cmdPermissionsList() {
+    const raw = readRawConfig();
+    const agents = (raw.agents ?? {});
+    const entries = Object.entries(agents);
+    if (entries.length === 0) {
+        console.log('No agents configured.');
+        return;
+    }
+    for (const [name, agent] of entries) {
+        const defaults = (agent.defaults ?? {});
+        const mode = defaults.permissionMode ?? 'dangerously-skip';
+        console.log(`${name}: ${mode}`);
+    }
+}
+function cmdPermissionsSet(args) {
+    const agentName = args[0];
+    const mode = args[1];
+    if (!agentName || !mode) {
+        console.error('Usage: tgcc permissions set <agent> <mode>');
+        console.error('Modes: dangerously-skip, acceptEdits, default, plan');
+        process.exit(1);
+    }
+    const validModes = ['dangerously-skip', 'acceptEdits', 'default', 'plan'];
+    if (!validModes.includes(mode)) {
+        console.error(`Invalid mode: ${mode}`);
+        console.error(`Valid modes: ${validModes.join(', ')}`);
+        process.exit(1);
+    }
+    const raw = readRawConfig();
+    const agents = (raw.agents ?? {});
+    if (!agents[agentName]) {
+        console.error(`Agent "${agentName}" not found.`);
+        process.exit(1);
+    }
+    updateConfig((cfg) => {
+        const a = (cfg.agents ?? {});
+        const agentCfg = a[agentName];
+        if (agentCfg) {
+            const defaults = (agentCfg.defaults ?? {});
+            defaults.permissionMode = mode;
+            agentCfg.defaults = defaults;
+        }
+    });
+    console.log(`Permission mode for "${agentName}" set to "${mode}".`);
+}
+function cmdPermissions(args) {
+    const subcommand = args[0];
+    switch (subcommand) {
+        case 'set':
+            cmdPermissionsSet(args.slice(1));
+            break;
+        case undefined:
+        case 'list':
+        case 'ls':
+            cmdPermissionsList();
+            break;
+        default:
+            console.error('Usage: tgcc permissions [set <agent> <mode>]');
+            console.error('');
+            console.error('  (no args)                  Show permission mode for all agents');
+            console.error('  set <agent> <mode>         Set agent default permissionMode');
+            console.error('');
+            console.error('Modes: dangerously-skip, acceptEdits, default, plan');
+            process.exit(1);
+    }
+}
+// ── Main ──
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    switch (command) {
+        case 'message':
+        case 'msg':
+            await cmdMessage(args.slice(1));
+            break;
+        case 'status':
+            await cmdStatus(args.slice(1));
+            break;
+        case 'agent':
+            cmdAgent(args.slice(1));
+            break;
+        case 'repo':
+            cmdRepo(args.slice(1));
+            break;
+        case 'permissions':
+            cmdPermissions(args.slice(1));
+            break;
+        case 'help':
+        case '--help':
+        case '-h':
+            printHelp();
+            break;
+        default:
+            if (!command) {
+                printHelp();
+            }
+            else {
+                console.error(`Unknown command: ${command}`);
+                printHelp();
+                process.exit(1);
+            }
+    }
+}
+function printHelp() {
+    console.log(`tgcc — Telegram ↔ Claude Code CLI
+
+Usage:
+  tgcc message [--agent <name>] [--session <id>] "your message"
+  tgcc status [--agent <name>]
+  tgcc agent add|remove|rename|list|repo
+  tgcc repo [add|remove|assign|clear|list]
+  tgcc permissions [set <agent> <mode>]
+  tgcc help
+
+Commands:
+  message       Send a message to a running agent
+  status        Show running agents and active sessions
+  agent         Manage agent registrations
+  repo          Manage repo registry
+  permissions   View/set agent permission modes
+  help          Show this help message
+
+Options:
+  --agent    Specify agent by name (auto-detected from cwd if omitted)
+  --session  Resume a specific session by ID`);
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map