shraga 0.1.79 → 0.1.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.79",
+  "version": "0.1.81",
   "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/background-jobs.ts

@@ -231,7 +231,15 @@ export async function startJob(owner: JobOwner, command: string): Promise<string
     // stdin is /dev/null so a child can never block on (or steal) input; stdout+stderr go straight
     // to the fd — nothing is buffered in this process, so a chatty job costs disk, not memory.
     const proc = spawn('/bin/sh', ['-c', buildShell(id, cmd)], {
-      cwd: owner.cwd, env: { ...childEnv(), ...owner.env },
+      cwd: owner.cwd,
+      env: {
+        ...childEnv(),
+        ...owner.env,
+        // A long-running launcher can gate on these: only a REGISTERED job gets a completion wake,
+        // so one started in the foreground orphans silently when its 60s tool call is killed.
+        SHRAGA_JOB_ID: id,
+        SHRAGA_BG_JOB: '1',
+      },
       detached: true, stdio: ['ignore', fd, fd],
     });
     j.pid = proc.pid;
@@ -251,6 +259,47 @@ export async function startJob(owner: JobOwner, command: string): Promise<string
   return id;
 }
 
+/** The little of a spawned child this module needs to adopt one (node's ChildProcess satisfies it). */
+type AdoptableProcess = {
+  pid?: number | null;
+  stdout?: { on(ev: 'data', cb: (chunk: unknown) => void): void } | null;
+  stderr?: { on(ev: 'data', cb: (chunk: unknown) => void): void } | null;
+  on(ev: 'close' | 'error', cb: (arg: never) => void): void;
+  unref?: () => void;
+};
+
+/**
+ * Register an ALREADY-RUNNING child as a background job. The Shell tool hands a foreground command
+ * over at its deadline instead of killing it: the work continues, and from here it is an ordinary job
+ * — polled with ShellOutput, and reported back to the session when it ends. Without this the deadline
+ * stays a kill, which is what abandoned a scheduled run midway.
+ */
+export function adoptJob(owner: JobOwner, command: string, proc: AdoptableProcess, seed = ''): string {
+  const id = `job-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const j: JobRecord = {
+    id, sessionId: owner.sessionId, uid: owner.uid, userEmail: owner.userEmail,
+    command: command.trim(), cwd: owner.cwd, startedAt: Date.now(), status: 'running',
+    pid: proc.pid ?? undefined,
+  };
+  // The child was spawned with pipes by the caller, so output is appended here rather than dup'd to
+  // an fd the way a job we spawn ourselves does it.
+  const append = (chunk: unknown) => {
+    const text = typeof chunk === 'string' ? chunk : String(chunk ?? '');
+    if (!text) return;
+    try { writeFileSync(logFile(id), text, { flag: 'a' }); } catch { /* the job outlives its log */ }
+  };
+  if (seed) append(seed);
+  proc.stdout?.on('data', append);
+  proc.stderr?.on('data', append);
+  proc.on('error', ((err: Error) => finish(id, 'error', undefined, `adopted job error: ${err?.message ?? err}`)) as never);
+  proc.on('close', ((code: number | null) => finish(id, 'exited', code ?? undefined)) as never);
+  proc.unref?.();
+  records.set(id, j);
+  save(j);
+  console.log(`${PREFIX} adopted ${id} pid=${j.pid} session=${j.sessionId.slice(0, 8)} cmd=${j.command.slice(0, 120)}`);
+  return id;
+}
+
 /** Record a terminal state exactly once, then schedule the follow-up. */
 function finish(id: string, status: JobStatus, exitCode?: number, note?: string): void {
   const j = records.get(id);
@@ -479,6 +528,7 @@ export function sessionJobRegistry(owner: JobOwner) {
   };
   return {
     start: (command: string) => startJob(owner, command),
+    adopt: (command: string, proc: AdoptableProcess, seed?: string) => adoptJob(owner, command, proc, seed),
     output(id: string): string | null {
       const j = mine(id);
       if (!j) return null;

package/src/server/scheduler/runner.ts

@@ -208,7 +208,7 @@ export async function runSchedule(
   // Tell the run how to report its own truthful outcome (scheduler/outcome.ts). Prompt tasks only:
   // a `bash` task's permission handler allows nothing but the task's own command, so such a run
   // could not write the file even if it wanted to — its exit code is already the truth there.
-  if (task.kind === 'prompt') {
+  if ((task.kind ?? 'prompt') === 'prompt') {
     // Cleared on RESUME too: a resume reuses the interrupted run's session id, so a declaration left
     // by the attempt that crashed would be adopted as this attempt's verdict. The contract is
     // re-stated for the same reason — the resumed turn must be able to declare for itself.
@@ -401,7 +401,7 @@ export async function runSchedule(
   // The run's OWN verdict beats "the turn returned" — see scheduler/outcome.ts. Deliberately after
   // the finally: the session lock is released by now, so a run that declared `pending` can be closed
   // by a later turn in this session (a background job's wake, a follow-up message) while we wait.
-  if (status === 'ok' && task.kind === 'prompt') {
+  if (status === 'ok' && (task.kind ?? 'prompt') === 'prompt') {
     const declared = await resolveDeclaredOutcome(sessionId, abortController, schedule.id);
     if (declared) {
       status = declared.status;

package/src/server/scheduler/storage.ts

@@ -27,11 +27,28 @@ export function saveThrottleState(state: Record<string, number>): void {
   renameSync(tmp, THROTTLE_FILE);
 }
 
+/**
+ * Schedules persisted before `task.kind` existed carry only the payload fields. Everything
+ * downstream branches on the discriminant, so infer it from the shape once, on load — a task
+ * missing its kind silently skipped the outcome contract and reported every run as `ok`.
+ * Only `prompt` is inferable: `bash` and `job` are both `{ command }`, and guessing between them
+ * would hand a run the wrong permission handler, so a kindless command task is left alone.
+ */
+function normalizeTask(task: Record<string, unknown>): void {
+  if (task.kind) return;
+  if (typeof task.prompt === 'string' || typeof task.promptFile === 'string') task.kind = 'prompt';
+}
+
+function normalizeSchedule(s: Schedule): Schedule {
+  if (s.task && typeof s.task === 'object') normalizeTask(s.task as unknown as Record<string, unknown>);
+  return s;
+}
+
 export function loadSchedules(): Schedule[] {
   if (!existsSync(FILE)) return [];
   try {
     const parsed = JSON.parse(readFileSync(FILE, 'utf-8'));
-    return Array.isArray(parsed) ? parsed : [];
+    return Array.isArray(parsed) ? parsed.map((s) => normalizeSchedule(s as Schedule)) : [];
   } catch (err) {
     console.error('[scheduler] failed to parse schedules.json:', err);
     return [];