shraga 0.1.24 → 0.1.26

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.24",
+  "version": "0.1.26",
   "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

@@ -153,11 +153,18 @@ app.use(express.urlencoded({
   verify: (req, _res, buf) => { (req as any).rawBody = buf; },
 }));
 
+// High-frequency poll routes (pty cwd, list refreshes) are quiet on success — they'd otherwise
+// drown real request logs. Errors and everything else still logs unconditionally.
+const QUIET_POLL_RE = /\/(cwd|ptys|sessions|workspace\/(pty-owners|layout))(\?|$)/;
+
 app.use((req, _res, next) => {
   const start = Date.now();
   const orig = _res.end.bind(_res);
   (_res as any).end = (...args: any[]) => {
-    console.log(`[http] ${req.method} ${req.url} → ${_res.statusCode} (${Date.now() - start}ms)`);
+    const quiet = req.method === 'GET' && _res.statusCode < 400 && QUIET_POLL_RE.test(req.url);
+    if (!quiet) {
+      console.log(`[http] ${req.method} ${req.url} → ${_res.statusCode} (${Date.now() - start}ms)`);
+    }
     return orig(...args);
   };
   next();

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

@@ -338,14 +338,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 +401,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);
     });
   });
 }