shraga 0.1.25 → 0.1.27

package/defaults/skills/scheduler.md

@@ -156,7 +156,7 @@ For **vendor webhooks** that can't send shraga auth (Stripe, GitHub, …), add a
 
 The system emits these onto the bus automatically — use them as the `source` of an event trigger to react to the agent's own lifecycle:
 
-- **`schedule.finished`** — fired when any time/manual schedule run completes. Payload: `{ scheduleId, name, status, sessionId, sessionUrl?, error? }`. `status` is `ok` | `error` | `aborted`. Chain automations off it, e.g.:
+- **`schedule.finished`** — fired when any time/manual schedule run completes. Payload: `{ scheduleId, name, status, sessionId, sessionUrl?, error? }`. `status` is `ok` | `error` | `aborted` — `aborted` covers both a user cancel and a run killed by a signal (a deploy/restart SIGTERMs in-flight jobs), so alerts matching `error` don't fire on interrupted runs. Chain automations off it, e.g.:
   ```json
   { "trigger": { "kind": "event", "source": "schedule.finished", "match": { "status": "error" } },
     "task": { "kind": "prompt", "prompt": "A scheduled run failed — investigate and post a summary." } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "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/claude.ts

@@ -74,7 +74,7 @@ export type WsEvent =
   | { type: 'text_delta'; text: string }
   | { type: 'tool_use'; tool: string; toolUseId: string; input: unknown }
   | { type: 'tool_use_input'; toolUseId: string; input: unknown }
-  | { type: 'tool_result'; toolUseId: string; output: string }
+  | { type: 'tool_result'; toolUseId: string; output: string; isError?: boolean }
   | { type: 'tool_result_image'; toolUseId: string; dataUrl: string }
   | { type: 'permission_request'; id: string; tool: string; input: Record<string, unknown> }
   | { type: 'question_request'; id: string; questions: AskQuestion[] }

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

@@ -446,7 +446,9 @@ export class ClaudeCodeEngine implements AgentEngine {
               const output = contentArr.length > 0
                 ? contentArr.filter((c: any) => c.type === 'text').map((c: any) => c.text ?? '').join('')
                 : String(block.content ?? '');
-              yield { type: 'tool_result', toolUseId: String(block.tool_use_id), output };
+              // `is_error` is the ONLY signal that a tool failed — the text alone is indistinguishable
+              // from a successful result. Scheduled `bash` tasks rely on it to notice a non-zero exit.
+              yield { type: 'tool_result', toolUseId: String(block.tool_use_id), output, isError: block.is_error === true };
 
               let foundImage = false;
               for (const c of contentArr) {

package/src/server/mcp.ts

@@ -52,11 +52,52 @@ function isHttpConfig(s: McpServerConfig): s is McpHttpServerConfig {
   return s.type === 'http';
 }
 
+/** `$VAR` / `${VAR}` placeholders inside a string. Same dialect as stdio `env` values, but also
+ *  substitutes when EMBEDDED (`Bearer $TOKEN`) — a header value is never the bare variable. */
+const PLACEHOLDER_RE = /\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g;
+
+/** Expand placeholders; unset var → '' (same as stdio env resolution). `found` records each hit. */
+function expandPlaceholders(value: string, found: string[]): string {
+  return value.replace(PLACEHOLDER_RE, (_m, braced, bare) => {
+    const v = process.env[braced || bare] || '';
+    found.push(v);
+    return v;
+  });
+}
+
+/** Resolve `$VAR` placeholders in an http entry's headers and url.
+ *  Without this, an authenticated remote MCP can only be configured by INLINING the secret into
+ *  data/mcps/*.json — which shraga auto-commits and pushes to the data repo (see saveMcpConfig →
+ *  dataSync.trackWrite). Entries with no placeholders are returned untouched. */
+function resolveHttpConfig(name: string, server: McpHttpServerConfig): McpHttpServerConfig | null {
+  const found: string[] = [];
+  const out: McpHttpServerConfig = { ...server };
+  if (typeof server.url === 'string') out.url = expandPlaceholders(server.url, found);
+  if (server.headers) {
+    const headers: Record<string, string> = {};
+    for (const [k, v] of Object.entries(server.headers)) {
+      headers[k] = typeof v === 'string' ? expandPlaceholders(v, found) : String(v ?? '');
+    }
+    out.headers = headers;
+  }
+  // Env-gate, mirroring stdio: an entry that DECLARES placeholders but resolves them all empty isn't
+  // configured for this deployment — skip it rather than mounting with a broken `Bearer ` credential.
+  if (found.length > 0 && found.every((v) => !v)) {
+    console.log(`[mcp] ${name}: skipped — required env placeholders not set in this deployment`);
+    return null;
+  }
+  return out;
+}
+
 /** Resolve env values: empty → process.env[same key], "$VAR" → process.env[VAR] */
 function resolveEnv(config: McpConfig): McpConfig {
   const resolved: McpConfig = {};
   for (const [name, server] of Object.entries(config)) {
-    if (isHttpConfig(server)) { resolved[name] = server; continue; }
+    if (isHttpConfig(server)) {
+      const http = resolveHttpConfig(name, server);
+      if (http) resolved[name] = http;
+      continue;
+    }
     if (!server.env) { resolved[name] = server; continue; }
     const env: Record<string, string> = {};
     for (const [k, v] of Object.entries(server.env)) {

package/src/server/scheduler/runner.ts

@@ -194,12 +194,21 @@ export async function runSchedule(
   let status: ScheduleRunSummary['status'] = 'ok';
   let error: string | undefined;
 
+  // A `bash` task is not exec'd — it's handed to the agent as a prompt, so the command's exit code
+  // reaches nobody: the agent reports the failure in prose, its own turn succeeds, the run is stored
+  // `ok`, and the failure notifier never fires. Track the tool_result of the task's OWN Bash call and
+  // fail the run with it, so a broken scheduled script alerts like a `job` does.
+  const taskBashToolUseIds = new Set<string>();
+  let bashFailure: string | undefined;
+
   onEvent({ type: 'schedule:run_started', scheduleId: schedule.id, sessionId, at: now });
 
   try {
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
       status = 'ok';
       error = undefined;
+      bashFailure = undefined;
+      taskBashToolUseIds.clear();
       try {
         for await (const ev of streamChat({
           prompt,
@@ -217,10 +226,12 @@ export async function runSchedule(
           } else if (ev.type === 'tool_use') {
             if (assistantText) { assistantBlocks.push({ type: 'text', text: assistantText }); assistantText = ''; }
             assistantBlocks.push({ type: 'tool_use', tool: ev.tool, toolUseId: ev.toolUseId, input: ev.input });
+            if (allowedCmd && ev.tool === 'Bash' && (ev.input as any)?.command === allowedCmd) taskBashToolUseIds.add(ev.toolUseId);
           } else if (ev.type === 'thinking_delta') {
             producedThinking = true;
           } else if (ev.type === 'tool_result') {
             assistantBlocks.push({ type: 'tool_result', toolUseId: ev.toolUseId, output: ev.output });
+            if (ev.isError && taskBashToolUseIds.has(ev.toolUseId)) bashFailure = ev.output;
           } else if (ev.type === 'done') {
             break;
           } else if (ev.type === 'error') {
@@ -238,6 +249,12 @@ export async function runSchedule(
         }
       }
 
+      // The agent turn can succeed while the command it was asked to run failed — that's the run failing.
+      if (status === 'ok' && bashFailure) {
+        status = 'error';
+        error = `Scheduled command failed:\n${bashFailure.slice(0, 4000)}`;
+      }
+
       if (status !== 'error') break;
 
       // The side-effect boundary. This is NOT an exact `ttft=-1` test — the engine emits events we
@@ -338,14 +355,20 @@ async function runJobSchedule(
       blocks: [{ type: 'text', text: `✅ Job completed successfully.\n\n${prefix}${output.trim() || '(no output)'}\n\`\`\`` }],
     });
   } catch (err: any) {
-    status = abortController.signal.aborted ? 'aborted' : 'error';
+    // A job killed by a SIGNAL was INTERRUPTED, not failed — the usual cause is systemd stopping the
+    // service (a deploy/restart), which SIGTERMs the whole cgroup including in-flight job children.
+    // Reporting that as `error` fires the failure notifier with an alert nobody can act on, whose
+    // "error" is just the job's own progress output (the process never got to throw anything).
+    // `aborted` is the existing status for "ended without failing" and the notifier ignores it.
+    const killed = typeof err?.signal === 'string';
+    status = abortController.signal.aborted || killed ? 'aborted' : 'error';
     error = err?.message ?? String(err);
     appendMessage(sessionId, {
       id: crypto.randomUUID(),
       role: 'assistant',
-      blocks: [{ type: 'text', text: `❌ Job failed.\n\n${prefix}${error}\n\`\`\`` }],
+      blocks: [{ type: 'text', text: `${killed ? '⏹️ Job interrupted' : '❌ Job failed'}.\n\n${prefix}${error}\n\`\`\`` }],
     });
-    console.error(`[scheduler] job run error for ${schedule.id}:`, error);
+    console[killed ? 'warn' : 'error'](`[scheduler] job run ${killed ? 'interrupted' : 'error'} for ${schedule.id}:`, error);
   } finally {
     clearInterval(partialInterval);
     unregisterLivePartial(sessionId);
@@ -395,10 +418,19 @@ function runCommandWithMarker(command: string, abortController: AbortController,
 
     abortController.signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
     child.on('error', reject);
-    child.on('close', (code) => {
+    child.on('close', (code, signal) => {
       const trimmed = output.trim();
-      if (code === 0) resolve(trimmed);
-      else reject(new Error(trimmed || `Command failed with exit code ${code}`));
+      if (code === 0) return resolve(trimmed);
+      // Always state HOW it ended. The old form used the command's own output as the message whenever
+      // it had produced any, so a killed job reported its progress logs as "the error" and the actual
+      // cause (exit code / signal) was lost — the failure was captured, but not why.
+      const how = signal ? `killed by ${signal}` : `exit code ${code}`;
+      const err: NodeJS.ErrnoException & { signal?: string } = new Error(
+        trimmed ? `Command ${how}. Output:\n${trimmed}` : `Command ${how}`,
+      );
+      // Carried so callers can tell an interrupted run (deploy/restart) from a real failure.
+      if (signal) err.signal = signal;
+      reject(err);
     });
   });
 }