shraga 0.1.56 → 0.1.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "description": "The teammate you delegate coding to — a self-hostable, multi-user AI coding agent web UI (Claude Code, with a pluggable engine seam).",
   "type": "module",
   "main": "./src/index.ts",

package/src/server/boot.ts

@@ -26,7 +26,7 @@ import { mountFeatures, registerFeature, resumeFeatureSession, collectFeatureFla
 import { registerSpaCatchAll } from './spa-catchall.ts';
 import { slackFeature } from './slack/feature.ts';
 import { dataPath } from './paths.ts';
-import { getAllSessions, getSession, getSessionHistory, upsertSession, appendMessage, saveConversation, loadConversation, setSessionDirectives, getAutoApprove, setAutoApprove, getSessionsByScheduleId, getSessionsVisibleTo, isSessionVisibleTo, setRunStatus, incrementRetryCount, resetRetryCount, getRunningSessions, getActiveLockCount, updateScheduledSessionStatus, setShuttingDown, backfillSessionVisibility, writePartial, readPartial, clearPartial, registerLivePartial, unregisterLivePartial, readLivePartial, acquireSessionLock, releaseSessionLock, replaceSessionLock, isSessionLocked, getSessionAbortController, forkSession, generateSessionTitle, type ConvBlock, type ConvMessage, type SessionMeta } from './sessions.ts';
+import { getAllSessions, getSession, getSessionHistory, upsertSession, appendMessage, saveConversation, loadConversation, setSessionDirectives, getAutoApprove, setAutoApprove, getSessionsByScheduleId, getSessionsVisibleTo, isSessionVisibleTo, setRunStatus, incrementRetryCount, getRunningSessions, getActiveLockCount, updateScheduledSessionStatus, setShuttingDown, backfillSessionVisibility, writePartial, readPartial, clearPartial, registerLivePartial, unregisterLivePartial, readLivePartial, acquireSessionLock, releaseSessionLock, replaceSessionLock, isSessionLocked, getSessionAbortController, forkSession, generateSessionTitle, type ConvBlock, type ConvMessage, type SessionMeta } from './sessions.ts';
 import { setBroadcaster } from './session-bus.ts';
 import * as scheduler from './scheduler/index.ts';
 import { initPolls } from './polls.ts';
@@ -1325,7 +1325,6 @@ async function runStream(ws: WebSocket, session: WsSession, sid: string, promptT
     if (blocks.length) writePartial(sid, blocks);
   }, 5_000);
 
-  resetRetryCount(sid);
   setRunStatus(sid, 'running', 'web');
 
   let stopReason = '';

package/src/server/engine/claude-code.ts

@@ -1,4 +1,5 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
+import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { signInternalToken } from '../auth.ts';
@@ -118,18 +119,44 @@ function logCacheUsage(usage: any, model: string): void {
   console.log(`[claude] Cache: hit=${hitRate}% read=${read} write=${created} uncached=${fresh} out=${usage.output_tokens ?? 0} model=${model}`);
 }
 
+/** SDK spawn hook: same call the SDK would make, plus `detached` (own process group). See the
+ *  call site for why. Shape mirrors the SDK's own spawnLocalProcess return. */
+function spawnDetached(cfg: { command: string; args: string[]; cwd?: string; env: Record<string, string | undefined>; signal?: AbortSignal }) {
+  const child = spawn(cfg.command, cfg.args, {
+    cwd: cfg.cwd,
+    env: cfg.env,
+    signal: cfg.signal,
+    // Keep SDK debug output visible when it is asked for; otherwise the SDK's own default.
+    stdio: ['pipe', 'pipe', cfg.env.DEBUG_CLAUDE_AGENT_SDK ? 'inherit' : 'ignore'],
+    detached: true,
+    windowsHide: true,
+  });
+  return {
+    stdin: child.stdin,
+    stdout: child.stdout,
+    get killed() { return child.killed; },
+    get exitCode() { return child.exitCode; },
+    kill: child.kill.bind(child),
+    on: child.on.bind(child),
+    once: child.once.bind(child),
+    off: child.off.bind(child),
+  };
+}
+
 const INLINE_MIMES = new Set(['image/jpeg', 'image/png', 'image/gif', 'image/webp', 'application/pdf']);
 
 async function* buildAttachmentPrompt(text: string, attachments: { path: string; name: string; mimeType: string }[], sessionId: string): AsyncIterable<any> {
   const content: any[] = [];
   const fileRefs: string[] = [];
   const audioRefs: string[] = [];
+  const inlined: string[] = [];
   for (const att of attachments) {
     if (INLINE_MIMES.has(att.mimeType)) {
       try {
         const buf = readFileSync(att.path);
         const blockType = att.mimeType === 'application/pdf' ? 'document' : 'image';
         content.push({ type: blockType, source: { type: 'base64', media_type: att.mimeType, data: buf.toString('base64') } });
+        inlined.push(`${att.name} (${att.path})`);
       } catch (err) {
         console.error(`[claude] Failed to read attachment ${att.path}:`, err);
         fileRefs.push(`${att.name} (at ${att.path} — failed to read)`);
@@ -143,6 +170,12 @@ async function* buildAttachmentPrompt(text: string, attachments: { path: string;
   }
   if (audioRefs.length > 0) text += `\n\n[Audio attached — transcribe with the mcp-audio tool (post_audio_transcribe { file }) before answering]: ${audioRefs.join(', ')}`;
   if (fileRefs.length > 0) text += `\n\n[Attached files — use Read tool to access]: ${fileRefs.join(', ')}`;
+  // Say IN THE TEXT that the inlined blocks exist. `text` carries the whole conversation history, so
+  // the image blocks sit tens of thousands of tokens above the actual question and the model has
+  // answered "I don't see any images attached" to a message that had four — the transcript proves the
+  // blocks were sent. This line makes the prompt agree with its own content, and names the on-disk
+  // paths so the model can Read them if it still can't see a block.
+  if (inlined.length > 0) text += `\n\n[${inlined.length} file(s) are attached to THIS message and included above as image/document blocks — look at them: ${inlined.join(', ')}]`;
   content.push({ type: 'text', text });
   yield { type: 'user', message: { role: 'user', content }, parent_tool_use_id: null, session_id: sessionId };
 }
@@ -273,6 +306,14 @@ export class ClaudeCodeEngine implements AgentEngine {
     const addonSuffix = getPromptSuffix(opts.turnHints);
     options['systemPrompt'] = `${IMMUTABLE_SYSTEM_PROMPT}\n\n${userPrompt}${addonSuffix ? `\n\n${addonSuffix}` : ''}`;
     if (opts.abortController) options['abortController'] = opts.abortController;
+    // Spawn the CLI in its OWN process group. The service manager signals the whole JOB on restart
+    // (`launchctl kickstart -k`, `systemctl restart`), so an inherited process group means the child
+    // dies instantly with SIGTERM — surfacing mid-reply as `exited with code 143` and making the
+    // server's 90s drain (gracefulShutdown) protect nothing: it only ever waited for a turn that was
+    // already dead. Detached, the signal reaches the server alone and the drain can finish the turn.
+    // Teardown is unaffected: the SDK still kills the child on abort/close and on process exit.
+    options['spawnClaudeCodeProcess'] = spawnDetached;
+
     // Passed as a FILE, never as `options.mcpServers` — the SDK would put the whole config (every MCP
     // server's credentials) on the CLI's argv, where `ps` / `/proc` / journald expose it. See
     // writeMcpConfigFile. Setting both would re-add the argv copy, so it's one or the other.

package/src/server/self-upgrade/index.ts

@@ -72,6 +72,13 @@ export class SelfUpgrade {
       if (running.length) {
         reasons.push(`${running.length} scheduled job(s) still running (${running.join(', ')}) — restarting now would kill them mid-flight; retry when idle or pass {"force":true}`);
       }
+      // Same failure, other origin: an interactive Slack/web turn is not a scheduled job, so the
+      // check above never saw it and upgrades cut live replies off mid-sentence (143). Any held
+      // session lock means someone is mid-turn.
+      const turns = this.o.runningTurns();
+      if (turns) {
+        reasons.push(`${turns} agent turn(s) in flight — restarting now would cut the reply off mid-stream; retry when idle or pass {"force":true}`);
+      }
     }
     const pkgPath = path.join(this.o.appRoot, 'package.json');
 
@@ -254,6 +261,13 @@ export class SelfUpgradeOptions {
     catch (err) { console.warn(`${TAG} could not read running jobs:`, (err as Error).message); return []; }
   };
 
+  /** Interactive agent turns in flight (Slack/web/API), counted off the live session locks. Same
+   *  lazy+guarded shape as runningJobs, and injectable for the same reason. */
+  public runningTurns: () => number = () => {
+    try { return require('../sessions.ts').getActiveLockCount() as number; }
+    catch (err) { console.warn(`${TAG} could not read running turns:`, (err as Error).message); return 0; }
+  };
+
   /** Injectable so the preflight is testable without depending on the test host's PATH. */
   public hasPython3: () => boolean = () => {
     try { return spawnSync('python3', ['--version'], { stdio: 'ignore' }).status === 0; }

package/src/server/sessions.ts

@@ -270,7 +270,16 @@ export function setRunStatus(sessionId: string, status: 'running' | 'idle', orig
   if (!s) return;
   s.runStatus = status;
   if (origin) s.runOrigin = origin;
-  if (status === 'idle') s.lastStopReason = stopReason;
+  if (status === 'idle') {
+    s.lastStopReason = stopReason;
+    // runRetryCount caps crash-resume loops (interrupt → resume → interrupt). Reaching 'idle' at all
+    // proves this turn was NOT killed by a restart — the guard above drops idle writes during a
+    // drain, and a hard kill never gets here — so the loop is broken and the count starts over.
+    // It used to be reset only on the web path, so Slack and scheduler sessions accumulated it
+    // forever: after two interruptions in their whole life they permanently lost auto-resume and
+    // every later restart ended at "please send a message to continue".
+    s.runRetryCount = 0;
+  }
   s.lastModified = Date.now();
   saveIndex(sessions);
 }

package/src/server/slack/bot.ts

@@ -385,7 +385,10 @@ export async function retrySlackSession(session: SessionMeta, prompt: string): P
           onUserQuestion: makeSlackQuestionHandler({ channel, threadTs, useUserToken }),
         }),
         session.sessionId,
-        { partial: false, artifacts: false },
+        // Partial-capture ON: a recovery turn is the one most likely to be interrupted again (a
+        // restart loop, an upgrade retry), and with it off the second interruption had nothing to
+        // preserve and resumed from the original prompt instead of the cut-off point.
+        { partial: true, artifacts: false },
       ),
     );
     if (replyTs) { console.log(`[slack-bot] recovery reply posted: ${channel} ts=${replyTs}`); invalidateChannelContext(channel); }