claude-tempo 0.1.0

package/dist/server.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = __importStar(require("crypto"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const client_1 = require("@temporalio/client");
+const config_1 = require("./config");
+const worker_1 = require("./worker");
+const ensemble_1 = require("./tools/ensemble");
+const cue_1 = require("./tools/cue");
+const set_part_1 = require("./tools/set-part");
+const listen_1 = require("./tools/listen");
+const recruit_1 = require("./tools/recruit");
+const report_1 = require("./tools/report");
+const terminate_1 = require("./tools/terminate");
+const set_name_1 = require("./tools/set-name");
+const channel_1 = require("./channel");
+const log = (...args) => console.error('[claude-tempo]', ...args);
+function getGitInfo(workDir) {
+    try {
+        const gitRoot = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd: workDir,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        let gitBranch;
+        try {
+            gitBranch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+                cwd: workDir,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            // not on a branch
+        }
+        return { gitRoot, gitBranch };
+    }
+    catch {
+        return {};
+    }
+}
+async function main() {
+    // Only activate when explicitly opted in via CLAUDE_TEMPO_ENSEMBLE
+    if (!process.env.CLAUDE_TEMPO_ENSEMBLE) {
+        log('CLAUDE_TEMPO_ENSEMBLE not set — MCP server idle (no workflow started)');
+        // Keep the process alive so Claude Code doesn't see a crash, but do nothing
+        const transport = new stdio_js_1.StdioServerTransport();
+        const idleServer = new mcp_js_1.McpServer({ name: 'claude-tempo', version: '0.1.0' });
+        await idleServer.connect(transport);
+        return;
+    }
+    const config = (0, config_1.getConfig)();
+    const isConductor = process.env.CLAUDE_TEMPO_CONDUCTOR === 'true';
+    let playerId = isConductor ? 'conductor' : crypto.randomBytes(4).toString('hex');
+    const getPlayerId = () => playerId;
+    const setPlayerId = (id) => { playerId = id; };
+    const workDir = process.cwd();
+    const { gitRoot, gitBranch } = getGitInfo(workDir);
+    log(`Starting ${isConductor ? 'conductor' : `peer ${playerId}`} in ${workDir}`);
+    // Connect Temporal client
+    const connection = await client_1.Connection.connect({
+        address: config.temporalAddress,
+    });
+    const client = new client_1.Client({
+        connection,
+        namespace: config.temporalNamespace,
+    });
+    // Start the Temporal worker (runs in background)
+    const worker = await (0, worker_1.createWorker)(config);
+    const workerRunPromise = worker.run();
+    workerRunPromise.catch((err) => {
+        log('Worker error:', err);
+        process.exit(1);
+    });
+    // Start the session workflow
+    const workflowId = isConductor
+        ? (0, config_1.conductorWorkflowId)(config.ensemble)
+        : `claude-session-${config.ensemble}-${playerId}`;
+    const sessionInput = {
+        metadata: {
+            playerId,
+            ensemble: config.ensemble,
+            hostname: os.hostname(),
+            workDir,
+            gitRoot,
+            gitBranch,
+            isConductor,
+        },
+        autoSummary: `Session in ${path.basename(workDir)}`,
+    };
+    const handle = await client.workflow.start('claudeSessionWorkflow', {
+        workflowId,
+        taskQueue: config.taskQueue,
+        args: [sessionInput],
+        workflowIdConflictPolicy: client_1.WorkflowIdConflictPolicy.USE_EXISTING,
+        workflowExecutionTimeout: '24 hours',
+        searchAttributes: {
+            ...(gitRoot ? { ClaudeTempoGitRoot: [gitRoot] } : {}),
+            ClaudeTempoHostname: [os.hostname()],
+            ClaudeTempoEnsemble: [config.ensemble],
+            ClaudeTempoPlayerId: [playerId],
+        },
+    });
+    log(`Workflow ${workflowId} started (or reconnected)`);
+    // If there's a conductor running, announce ourselves
+    if (!isConductor) {
+        try {
+            const conductorHandle = client.workflow.getHandle((0, config_1.conductorWorkflowId)(config.ensemble));
+            await conductorHandle.signal('receiveMessage', {
+                from: playerId,
+                text: `Player ${playerId} joined from ${workDir}`,
+            });
+        }
+        catch {
+            // No conductor running — that's fine
+        }
+    }
+    // Create MCP server
+    const serverInstructions = `You are part of the "${config.ensemble}" ensemble of Claude Code sessions coordinated via Temporal. ` +
+        `Your temporary player ID is "${playerId}". ` +
+        `IMPORTANT: If you receive a message instructing you to call \`set_name\`, do so immediately before anything else. ` +
+        `When you receive a message from another session, treat it like a coworker asking for help — respond promptly, then resume your work. ` +
+        `Use \`set_name\` to give yourself a human-readable name. ` +
+        `Use \`ensemble\` to see who else is active. ` +
+        `Use \`cue\` to reply directly to the player who messaged you, or to ask others for help. ` +
+        `Use \`recruit\` if you need a session in a directory where none exists. ` +
+        `Use \`report\` to notify the conductor of task completion, blockers, or questions — always report when you finish a recruited task.`;
+    const mcpServer = new mcp_js_1.McpServer({
+        name: 'claude-tempo',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            experimental: { 'claude/channel': {} },
+        },
+        instructions: serverInstructions,
+    });
+    // Register tools
+    (0, ensemble_1.registerEnsembleTool)(mcpServer, client, config, getPlayerId, workflowId);
+    (0, cue_1.registerCueTool)(mcpServer, client, config, getPlayerId);
+    (0, set_part_1.registerSetPartTool)(mcpServer, handle);
+    (0, set_name_1.registerSetNameTool)(mcpServer, client, config, handle, getPlayerId, setPlayerId);
+    (0, listen_1.registerListenTool)(mcpServer, handle);
+    (0, recruit_1.registerRecruitTool)(mcpServer, client, config, getPlayerId);
+    (0, report_1.registerReportTool)(mcpServer, client, config, getPlayerId);
+    (0, terminate_1.registerTerminateTool)(mcpServer, client, config, getPlayerId);
+    // Start message poller — push messages into Claude Code via channel notifications
+    const stopPoller = (0, channel_1.startMessagePoller)(handle, async (messages) => {
+        for (const msg of messages) {
+            log(`Message from ${msg.from}: ${msg.text}`);
+            try {
+                await mcpServer.server.notification({
+                    method: 'notifications/claude/channel',
+                    params: {
+                        content: msg.text,
+                        meta: {
+                            from_player: msg.from,
+                            sent_at: msg.timestamp,
+                        },
+                    },
+                });
+            }
+            catch (err) {
+                log('Channel notification error:', err);
+            }
+        }
+    });
+    // Connect MCP transport
+    const transport = new stdio_js_1.StdioServerTransport();
+    await mcpServer.connect(transport);
+    log('MCP server connected');
+    // Graceful shutdown
+    const shutdown = async () => {
+        log('Shutting down...');
+        stopPoller();
+        try {
+            await handle.signal('shutdown');
+        }
+        catch {
+            try {
+                await handle.cancel();
+            }
+            catch {
+                // workflow may already be gone
+            }
+        }
+        worker.shutdown();
+        await workerRunPromise.catch(() => { });
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "claude-tempo",
+  "version": "0.1.0",
+  "description": "MCP server for multi-session Claude Code coordination via Temporal",
+  "type": "commonjs",
+  "main": "dist/server.js",
+  "bin": {
+    "claude-tempo": "dist/cli.js",
+    "claude-tempo-server": "dist/server.js"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"const{bundleWorkflowCode}=require('@temporalio/worker');const path=require('path');const fs=require('fs');bundleWorkflowCode({workflowsPath:path.resolve('dist/workflows/session.js')}).then(b=>{fs.writeFileSync('workflow-bundle.js',b.code);console.log('Workflow bundle created')})\"",
+    "dev": "ts-node src/server.ts",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "@temporalio/activity": "~1.11.7",
+    "@temporalio/client": "~1.11.7",
+    "@temporalio/worker": "~1.11.7",
+    "@temporalio/workflow": "~1.11.7",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.5.0"
+  },
+  "license": "MIT",
+  "trustedDependencies": [
+    "@swc/core",
+    "protobufjs"
+  ]
+}

package/src/channel.ts

@@ -0,0 +1,35 @@
+import { WorkflowHandle } from '@temporalio/client';
+import { Message } from './types';
+
+const log = (...args: unknown[]) => console.error('[claude-tempo:poller]', ...args);
+
+const POLL_INTERVAL_MS = 2000;
+
+export function startMessagePoller(
+  handle: WorkflowHandle,
+  onMessages: (messages: Message[]) => void,
+): () => void {
+  let stopped = false;
+
+  const poll = async () => {
+    if (stopped) return;
+    try {
+      const messages: Message[] = await handle.query('pendingMessages');
+      if (messages.length > 0) {
+        const ids = messages.map((m) => m.id);
+        await handle.signal('markDelivered', ids);
+        onMessages(messages);
+      }
+    } catch (err) {
+      // Workflow may be continuing-as-new or shutting down
+      log('Poll error (may be transient):', err);
+    }
+  };
+
+  const interval = setInterval(poll, POLL_INTERVAL_MS);
+
+  return () => {
+    stopped = true;
+    clearInterval(interval);
+  };
+}