@inetafrica/open-claudia 1.6.0 → 1.7.0

package/bot.js

@@ -170,7 +170,6 @@ bot.setMyCommands([
   { command: "compact", description: "Summarize conversation context" },
   { command: "continue", description: "Resume last conversation" },
   { command: "worktree", description: "Toggle isolated git branch" },
-  { command: "agents", description: "Toggle direct/parallel agent mode" },
   { command: "cron", description: "Manage scheduled tasks" },
   { command: "vault", description: "Manage credentials (password required)" },
   { command: "soul", description: "View/edit assistant identity" },
@@ -268,8 +267,7 @@ const savedState = loadState();
 
 // ── State ───────────────────────────────────────────────────────────
 let currentSession = savedState.currentSession || null;
-let runningProcess = null;        // Primary process (direct mode)
-let runningTasks = new Map();     // taskId -> { proc, statusMessageId, streamInterval, startTime } (parallel mode)
+let runningProcess = null;
 let statusMessageId = null;
 let streamBuffer = "";
 let streamInterval = null;
@@ -279,14 +277,13 @@ let activeCrons = new Map();
 let pendingVaultUnlock = false; // Waiting for password
 let pendingVaultAction = null;  // What to do after unlock
 let isFirstMessage = !lastSessionId; // Track if this is first message in session
-let taskCounter = 0;
 
 let settings = savedState.settings || {
-  model: null, effort: null, budget: null, permissionMode: null, worktree: false, agentMode: "direct",
+  model: null, effort: null, budget: null, permissionMode: null, worktree: false,
 };
 
 function resetSettings() {
-  settings = { model: null, effort: null, budget: null, permissionMode: null, worktree: false, agentMode: settings.agentMode };
+  settings = { model: null, effort: null, budget: null, permissionMode: null, worktree: false };
 }
 
 function isAuthorized(msg) {
@@ -656,19 +653,6 @@ function parseStreamEvents(data) {
   return events;
 }
 
-/**
- * Route to the appropriate runner based on agent mode setting.
- * In direct mode: serial execution with shared session.
- * In parallel mode: concurrent independent processes.
- * Commands like /compact and /continue always use direct mode (they need session context).
- */
-async function runClaudeRouted(prompt, cwd, replyToMsgId, opts = {}) {
-  if (opts.forceDirect || settings.agentMode !== "parallel") {
-    return runClaude(prompt, cwd, replyToMsgId, opts);
-  }
-  return runClaudeParallel(prompt, cwd, replyToMsgId, opts);
-}
-
 function buildClaudeArgs(prompt, opts = {}) {
   const args = ["-p", "--verbose", "--output-format", "stream-json",
     "--append-system-prompt", buildSystemPrompt()];
@@ -780,19 +764,29 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     try {
       const finalText = assistantText || "(no output)";
       const chunks = splitMessage(finalText);
-      // Send final result as a new message (triggers notification)
-      const sent = await send(chunks[0], { replyTo: replyToMsgId });
-      if (!sent) {
-        // Fallback: if the first send failed completely, try without any options
-        await send(chunks[0]);
-      }
-      for (let i = 1; i < chunks.length; i++) {
-        await send(chunks[i]);
+      const firstChunk = chunks[0];
+
+      // If the progress message already shows the final text, just edit it clean
+      // (no need to send a duplicate). Only send a new message for long tasks
+      // or multi-chunk responses to trigger a notification.
+      const progressAlreadyHasFinal = statusMessageId && lastUpdate &&
+        firstChunk.length < 4000 && chunks.length === 1 &&
+        lastUpdate.includes(firstChunk.slice(0, 200));
+
+      if (progressAlreadyHasFinal) {
+        // Edit the progress message to show clean final text (remove tool steps header)
+        await editMessage(statusMessageId, firstChunk);
+      } else {
+        // Send final result as a new message (triggers notification)
+        const sent = await send(firstChunk, { replyTo: replyToMsgId });
+        if (!sent) await send(firstChunk);
+        for (let i = 1; i < chunks.length; i++) {
+          await send(chunks[i]);
+        }
       }
       if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
     } catch (e) {
       console.error("Final message delivery failed:", e.message);
-      // Last-resort attempt to notify user something went wrong
       await send("Task completed but failed to deliver the response. Send /continue to see the result.");
     }
     if (settings.budget) settings.budget = null;
@@ -816,126 +810,6 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   });
 }
 
-/**
- * Run Claude in parallel mode — each call gets its own independent process.
- * No queueing, no shared session. Multiple tasks can run simultaneously.
- */
-async function runClaudeParallel(prompt, cwd, replyToMsgId, opts = {}) {
-  bot.sendChatAction(CHAT_ID, "typing").catch(() => {});
-
-  const taskId = `task-${++taskCounter}`;
-  let taskStatusMsgId = null;
-  let taskStreamBuf = "";
-  let taskText = "";
-  let taskToolUses = [];
-  let taskCurrentTool = null;
-  let taskCurrentToolDetail = "";
-  let taskSessionId = null;
-
-  // Build args — always fresh session in parallel mode (no --resume)
-  const args = ["-p", "--verbose", "--output-format", "stream-json",
-    "--append-system-prompt", buildSystemPrompt()];
-  if (settings.model) args.push("--model", settings.model);
-  if (settings.effort) args.push("--effort", settings.effort);
-  if (settings.budget) args.push("--max-budget-usd", String(settings.budget));
-  if (settings.permissionMode) args.push("--permission-mode", settings.permissionMode);
-  else args.push("--dangerously-skip-permissions");
-  if (settings.worktree) args.push("--worktree");
-  args.push(prompt);
-
-  const proc = spawn(CLAUDE_PATH, args, {
-    cwd,
-    env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME },
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: process.platform !== "win32",
-  });
-
-  const startTime = Date.now();
-  let taskInterval = null;
-  let lastUpdate = "";
-
-  // Adaptive progress updates
-  const scheduleTaskUpdate = () => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-    const interval = elapsed > 120 ? 5000 : 2000;
-    taskInterval = setTimeout(doTaskUpdate, interval);
-  };
-  const doTaskUpdate = async () => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-    try {
-      bot.sendChatAction(CHAT_ID, "typing").catch(() => {});
-      const display = formatProgress(taskText, taskToolUses, taskCurrentTool, elapsed, taskCurrentToolDetail);
-      if (display && display !== lastUpdate) {
-        if (!taskStatusMsgId && taskText) {
-          taskStatusMsgId = await send(display.length > 4000 ? display.slice(-4000) : display, { replyTo: replyToMsgId });
-        } else if (taskStatusMsgId) {
-          await editMessage(taskStatusMsgId, display.length > 4000 ? display.slice(-4000) : display);
-        }
-        lastUpdate = display;
-      }
-    } catch (e) {
-      console.error(`Task ${taskId} progress error:`, e.message);
-    }
-    if (runningTasks.has(taskId)) scheduleTaskUpdate();
-  };
-
-  runningTasks.set(taskId, { proc, startTime, prompt: prompt.slice(0, 50) });
-  scheduleTaskUpdate();
-
-  proc.stdout.on("data", (data) => {
-    taskStreamBuf += data.toString();
-    const events = parseStreamEvents(taskStreamBuf);
-    const lastNewline = taskStreamBuf.lastIndexOf("\n");
-    taskStreamBuf = lastNewline >= 0 ? taskStreamBuf.slice(lastNewline + 1) : taskStreamBuf;
-    for (const evt of events) {
-      if (evt.type === "assistant" && evt.message?.content) {
-        for (const block of evt.message.content) {
-          if (block.type === "text") taskText += block.text;
-          else if (block.type === "tool_use") {
-            taskCurrentTool = block.name;
-            taskToolUses.push(block.name);
-            const input = block.input || {};
-            if (block.name === "Bash" && input.command) taskCurrentToolDetail = input.command.slice(0, 80);
-            else if ((block.name === "Read" || block.name === "Edit" || block.name === "Write") && input.file_path)
-              taskCurrentToolDetail = input.file_path.split("/").slice(-2).join("/");
-            else if (block.name === "Grep" && input.pattern) taskCurrentToolDetail = input.pattern.slice(0, 40);
-            else if (block.name === "Glob" && input.pattern) taskCurrentToolDetail = input.pattern;
-            else taskCurrentToolDetail = "";
-          }
-        }
-      }
-      if (evt.type === "result" && evt.session_id) taskSessionId = evt.session_id;
-      if (evt.type === "result" && evt.result) taskText = evt.result;
-    }
-  });
-
-  proc.stderr.on("data", (d) => console.error(`Task ${taskId} STDERR:`, d.toString()));
-
-  proc.on("close", async (code) => {
-    runningTasks.delete(taskId);
-    clearTimeout(taskInterval);
-    try {
-      const finalText = taskText || "(no output)";
-      const chunks = splitMessage(finalText);
-      const sent = await send(chunks[0], { replyTo: replyToMsgId });
-      if (!sent) await send(chunks[0]);
-      for (let i = 1; i < chunks.length; i++) await send(chunks[i]);
-      if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
-    } catch (e) {
-      console.error(`Task ${taskId} final delivery failed:`, e.message);
-      await send("Task completed but failed to deliver the response.");
-    }
-  });
-
-  proc.on("error", async (err) => {
-    runningTasks.delete(taskId);
-    clearTimeout(taskInterval);
-    await send(`Task error: ${err.message}`, { replyTo: replyToMsgId });
-  });
-
-  return taskId;
-}
-
 async function runClaudeSilent(prompt, cwd, label) {
   return new Promise((resolve) => {
     const args = ["-p", "--output-format", "text", "--verbose",
@@ -1046,7 +920,7 @@ bot.onText(/\/help/, (msg) => {
   if (!isAuthorized(msg)) return;
   send([
     "Session: /session /sessions /projects /continue /status /stop /end",
-    "Settings: /model /effort /budget /plan /compact /worktree /agents",
+    "Settings: /model /effort /budget /plan /compact /worktree /mode",
     "Automation: /cron /vault /soul",
     "System: /restart /upgrade",
     "",
@@ -1154,45 +1028,27 @@ bot.onText(/\/compact/, async (msg) => { if (!isAuthorized(msg)) return; if (!re
 bot.onText(/\/continue$/, async (msg) => { if (!isAuthorized(msg)) return; if (!requireSession(msg)) return; await runClaude("continue where we left off", currentSession.dir, msg.message_id, { continueSession: true }); });
 bot.onText(/\/worktree$/, (msg) => { if (!isAuthorized(msg)) return; settings.worktree = !settings.worktree; send(settings.worktree ? "Worktree on." : "Worktree off."); });
 
-bot.onText(/\/agents$/, (msg) => {
+bot.onText(/\/mode$/, async (msg) => {
   if (!isAuthorized(msg)) return;
-  const mode = settings.agentMode || "direct";
-  send(`Agent mode: *${mode}*\n\n` +
-    `*direct* — one task at a time, shared session context, queues messages\n` +
-    `*parallel* — concurrent tasks, independent sessions, no queue`, {
+  await send("Bot mode: *direct* (default)\n\nSwitch to agent mode for non-blocking execution.\nIn agent mode, heavy tasks run in the background and you can keep chatting.", {
     parseMode: "Markdown",
     keyboard: { inline_keyboard: [
-      [{ text: mode === "direct" ? "Direct (active)" : "Switch to Direct", callback_data: "am:direct" },
-       { text: mode === "parallel" ? "Parallel (active)" : "Switch to Parallel", callback_data: "am:parallel" }],
+      [{ text: "Switch to Agent Mode", callback_data: "mode:agent" }],
     ] },
   });
 });
 
 bot.onText(/\/stop/, async (msg) => {
   if (!isAuthorized(msg)) return;
-
-  // Stop parallel tasks
-  if (runningTasks.size > 0) {
-    for (const [taskId, task] of runningTasks) {
-      try { process.kill(-task.proc.pid, "SIGTERM"); } catch (e) {
-        try { task.proc.kill("SIGTERM"); } catch (e2) {}
-      }
-      setTimeout(() => { try { process.kill(-task.proc.pid, "SIGKILL"); } catch (e) {} }, 3000);
-    }
-    const count = runningTasks.size;
-    runningTasks.clear();
-    await send(`Cancelled ${count} task${count > 1 ? "s" : ""}.`);
-    return;
-  }
-
-  // Stop direct mode process
   if (runningProcess) {
     const pid = runningProcess.pid;
     try {
+      // Kill entire process group to catch child processes (dev servers, etc.)
       process.kill(-pid, "SIGTERM");
     } catch (e) {
       try { runningProcess.kill("SIGTERM"); } catch (e2) {}
     }
+    // Force kill after 3 seconds if still alive
     setTimeout(() => {
       try { process.kill(-pid, "SIGKILL"); } catch (e) {}
     }, 3000);
@@ -1200,33 +1056,19 @@ bot.onText(/\/stop/, async (msg) => {
     if (streamInterval) clearTimeout(streamInterval);
     messageQueue = [];
     await send("Cancelled.");
-    return;
   }
-
-  await send("Nothing running.");
+  else await send("Nothing running.");
 });
 
 bot.onText(/\/status/, (msg) => {
   if (!isAuthorized(msg)) return;
   if (!currentSession) return send("No session.", { keyboard: { inline_keyboard: [[{ text: "Pick", callback_data: "show:projects" }]] } });
-  const mode = settings.agentMode || "direct";
-  const lines = [
+  send([
     `Project: ${currentSession.name}`,
-    `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"} | Mode: ${mode}`,
+    `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"}`,
     `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"} | Crons: ${activeCrons.size}`,
-  ];
-  if (mode === "parallel" && runningTasks.size > 0) {
-    lines.push(`Running: ${runningTasks.size} task${runningTasks.size > 1 ? "s" : ""}`);
-    for (const [id, task] of runningTasks) {
-      const elapsed = Math.floor((Date.now() - task.startTime) / 1000);
-      lines.push(`  ${id}: ${task.prompt}... (${elapsed}s)`);
-    }
-  } else if (runningProcess) {
-    lines.push("Working...");
-  } else {
-    lines.push("Ready.");
-  }
-  send(lines.join("\n"));
+    runningProcess ? "Working..." : "Ready.",
+  ].join("\n"));
 });
 
 bot.onText(/\/end/, (msg) => {
@@ -1362,7 +1204,16 @@ bot.on("callback_query", async (q) => {
   if (d.startsWith("m:")) { settings.model = d.slice(2) === "default" ? null : d.slice(2); await send(`Model: ${settings.model || "default"}`); return; }
   if (d.startsWith("e:")) { const e = d.slice(2); settings.effort = e === "default" ? null : e; await send(`Effort: ${settings.effort || "default"}`); return; }
   if (d.startsWith("b:")) { const b = d.slice(2); settings.budget = b === "none" ? null : parseFloat(b); await send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`); return; }
-  if (d.startsWith("am:")) { settings.agentMode = d.slice(3); saveState(); await send(`Agent mode: ${settings.agentMode}`); return; }
+
+  // Mode switching — writes mode file and restarts bot
+  if (d.startsWith("mode:")) {
+    const newMode = d.slice(5);
+    const modeFile = path.join(CONFIG_DIR, ".bot-mode");
+    fs.writeFileSync(modeFile, newMode);
+    await send(`Switching to ${newMode} mode... restarting.`);
+    setTimeout(() => process.exit(0), 500); // Let launchd/systemd restart with new mode
+    return;
+  }
 
   // Cron presets
   if (d.startsWith("cp:") && d !== "cp:clear") {
@@ -1396,7 +1247,7 @@ bot.on("voice", async (msg) => {
     try { fs.unlinkSync(oggPath); } catch (e) {}
     if (!transcript) return send("Couldn't transcribe. Try typing it.");
     await send(`Heard: "${transcript}"`, { replyTo: msg.message_id });
-    await runClaudeRouted(transcript, currentSession.dir, msg.message_id);
+    await runClaude(transcript, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Voice failed: ${err.message}`); }
 });
 
@@ -1411,7 +1262,7 @@ bot.on("audio", async (msg) => {
     try { fs.unlinkSync(p); } catch (e) {}
     if (!t) return send("Couldn't transcribe.");
     await send(`Heard: "${t}"`, { replyTo: msg.message_id });
-    await runClaudeRouted(t, currentSession.dir, msg.message_id);
+    await runClaude(t, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Audio failed: ${err.message}`); }
 });
 
@@ -1422,7 +1273,7 @@ bot.on("photo", async (msg) => {
   try {
     const p = await downloadFile(msg.photo[msg.photo.length - 1].file_id, ".jpg");
     const caption = msg.caption || "Describe this image. If code/UI/error — explain and fix.";
-    await runClaudeRouted(`Image at ${p}\n\nView it, then: ${caption}`, currentSession.dir, msg.message_id);
+    await runClaude(`Image at ${p}\n\nView it, then: ${caption}`, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Image failed: ${err.message}`); }
 });
 
@@ -1450,7 +1301,7 @@ bot.on("document", async (msg) => {
       prompt = `File received: ${fileName} (${mime})\nSaved at: ${savePath}\n\nRead this file and ${caption || "summarize its contents. If it's code, explain what it does. If it's a document, give key points."}`;
     }
     await send(`File saved: ${fileName}`, { replyTo: msg.message_id });
-    await runClaudeRouted(prompt, currentSession.dir, msg.message_id);
+    await runClaude(prompt, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Failed: ${err.message}`); }
 });
 
@@ -1555,7 +1406,7 @@ bot.on("message", async (msg) => {
     }
   }
 
-  await runClaudeRouted(prompt, currentSession.dir, msg.message_id);
+  await runClaude(prompt, currentSession.dir, msg.message_id);
 });
 
 // ── Startup ─────────────────────────────────────────────────────────

package/docker-entrypoint.sh

@@ -0,0 +1,47 @@
+#!/bin/sh
+set -e
+
+CONFIG_DIR="$HOME/.open-claudia"
+ENV_FILE="$CONFIG_DIR/.env"
+
+mkdir -p "$CONFIG_DIR"
+
+# If .env doesn't exist and env vars are set, auto-configure
+if [ ! -f "$ENV_FILE" ] && [ -n "$TELEGRAM_BOT_TOKEN" ]; then
+  echo "Auto-configuring from environment variables..."
+
+  cat > "$ENV_FILE" <<ENVEOF
+TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN}
+TELEGRAM_CHAT_ID=${TELEGRAM_CHAT_ID:-}
+WORKSPACE=${WORKSPACE:-$HOME/Workspace}
+CLAUDE_PATH=${CLAUDE_PATH:-claude}
+SOUL_FILE=$CONFIG_DIR/soul.md
+CRONS_FILE=$CONFIG_DIR/crons.json
+VAULT_FILE=$CONFIG_DIR/vault.enc
+AUTH_FILE=$CONFIG_DIR/auth.json
+ONBOARDED=true
+WEB_UI=${WEB_UI:-true}
+WEB_PORT=${WEB_PORT:-8080}
+ENVEOF
+
+  # Create workspace directory
+  mkdir -p "${WORKSPACE:-$HOME/Workspace}"
+
+  # Create default soul
+  if [ ! -f "$CONFIG_DIR/soul.md" ]; then
+    cat > "$CONFIG_DIR/soul.md" <<'SOUL'
+You are a helpful AI coding assistant running via Telegram.
+Keep responses concise — this is a mobile screen.
+Act on screenshots, fix bugs, implement designs.
+SOUL
+  fi
+
+  # Create empty files if missing
+  [ -f "$CONFIG_DIR/crons.json" ] || echo "[]" > "$CONFIG_DIR/crons.json"
+  [ -f "$CONFIG_DIR/auth.json" ] || echo '{"authorized":[],"pending":[]}' > "$CONFIG_DIR/auth.json"
+
+  echo "Configuration written to $ENV_FILE"
+fi
+
+# Execute the main command
+exec "$@"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Your always-on AI coding assistant — Claude Code via Telegram",
   "main": "bot.js",
   "bin": {
@@ -13,6 +13,7 @@
   },
   "files": [
     "bot.js",
+    "bot-agent.js",
     "vault.js",
     "setup.js",
     "web.js",
@@ -20,6 +21,7 @@
     "bin/",
     "k8s/",
     "Dockerfile",
+    "docker-entrypoint.sh",
     ".dockerignore",
     ".env.example",
     "README.md"

package/k8s/deployment.yaml

@@ -1,61 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: open-claudia
-  labels:
-    app: open-claudia
-spec:
-  replicas: 1
-  strategy:
-    type: Recreate  # Only one instance can poll Telegram
-  selector:
-    matchLabels:
-      app: open-claudia
-  template:
-    metadata:
-      labels:
-        app: open-claudia
-    spec:
-      containers:
-        - name: open-claudia
-          image: registry.example.com/open-claudia:latest
-          ports:
-            - containerPort: 8080
-              name: web
-          env:
-            - name: WEB_UI
-              value: "true"
-            - name: WEB_PORT
-              value: "8080"
-            - name: ANTHROPIC_API_KEY
-              valueFrom:
-                secretKeyRef:
-                  name: open-claudia-secrets
-                  key: anthropic-api-key
-                  optional: true
-          volumeMounts:
-            - name: data
-              mountPath: /data
-          resources:
-            requests:
-              memory: "256Mi"
-              cpu: "100m"
-            limits:
-              memory: "1Gi"
-              cpu: "1000m"
-          livenessProbe:
-            httpGet:
-              path: /api/status
-              port: 8080
-            initialDelaySeconds: 10
-            periodSeconds: 30
-          readinessProbe:
-            httpGet:
-              path: /api/status
-              port: 8080
-            initialDelaySeconds: 5
-            periodSeconds: 10
-      volumes:
-        - name: data
-          persistentVolumeClaim:
-            claimName: open-claudia-data

package/k8s/ingress.yaml

@@ -1,26 +0,0 @@
-apiVersion: networking.k8s.io/v1
-kind: Ingress
-metadata:
-  name: open-claudia
-  labels:
-    app: open-claudia
-  annotations:
-    # Uncomment for cert-manager TLS
-    # cert-manager.io/cluster-issuer: letsencrypt-prod
-spec:
-  rules:
-    - host: claudia.example.com  # Replace with your domain
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: open-claudia
-                port:
-                  number: 8080
-  # Uncomment for TLS
-  # tls:
-  #   - hosts:
-  #       - claudia.example.com
-  #     secretName: open-claudia-tls

package/k8s/pvc.yaml

@@ -1,12 +0,0 @@
-apiVersion: v1
-kind: PersistentVolumeClaim
-metadata:
-  name: open-claudia-data
-  labels:
-    app: open-claudia
-spec:
-  accessModes:
-    - ReadWriteOnce
-  resources:
-    requests:
-      storage: 1Gi

package/k8s/secret.yaml

@@ -1,10 +0,0 @@
-apiVersion: v1
-kind: Secret
-metadata:
-  name: open-claudia-secrets
-  labels:
-    app: open-claudia
-type: Opaque
-stringData:
-  # Replace with your actual API key
-  anthropic-api-key: "sk-ant-your-key-here"

package/k8s/service.yaml

@@ -1,14 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: open-claudia
-  labels:
-    app: open-claudia
-spec:
-  type: ClusterIP
-  ports:
-    - port: 8080
-      targetPort: 8080
-      name: web
-  selector:
-    app: open-claudia