shraga 0.1.12 → 0.1.13

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

@@ -12,6 +12,7 @@ import { DEFAULT_MODEL } from '../directives.ts';
 import { resolveModelSwitch } from '../model-aliases.ts';
 import type { WsEvent, AskQuestion, QuestionAnswers, QuestionHandler } from '../claude.ts';
 import type { AgentEngine, EngineStreamOpts, EngineModel } from './types.ts';
+import { getPromptSuffix } from '../prompt-suffix.ts';
 
 const PROJECT_ROOT = path.resolve(import.meta.dirname, '..', '..', '..');
 const IMMUTABLE_SYSTEM_PROMPT = readFileSync(path.resolve(import.meta.dirname, '../../../defaults/system-prompt.md'), 'utf-8');
@@ -265,8 +266,10 @@ export class ClaudeCodeEngine implements AgentEngine {
     if (effort) options['effort'] = effort;
 
     const userPrompt = config.systemPrompt || DEFAULT_USER_PROMPT;
-    const voiceSuffix = ""; // voice mode is an optional add-on; not present in this build
-    options['systemPrompt'] = `${IMMUTABLE_SYSTEM_PROMPT}\n\n${userPrompt}${voiceSuffix}`;
+    // Optional add-ons may append a system-prompt suffix decided off the opaque turn hints (add-on-owned
+    // text). With nothing registered (CE's own state) this is '' and the prompt is byte-identical to before.
+    const addonSuffix = getPromptSuffix(opts.turnHints);
+    options['systemPrompt'] = `${IMMUTABLE_SYSTEM_PROMPT}\n\n${userPrompt}${addonSuffix ? `\n\n${addonSuffix}` : ''}`;
     if (opts.abortController) options['abortController'] = opts.abortController;
     if (opts.mcpServers && Object.keys(opts.mcpServers).length > 0) options['mcpServers'] = opts.mcpServers;
 

package/src/server/engine/types.ts

@@ -23,7 +23,9 @@ export interface EngineStreamOpts {
   onPermissionRequest?: PermissionHandler;
   onDestructiveApproval?: PermissionHandler;
   onUserQuestion?: QuestionHandler;
-  voiceMode?: boolean;
+  /** Opaque per-send hints bag, forwarded verbatim from the client. The core interprets no key of it;
+   *  an add-on engine reads its own keys (e.g. a duplex engine's `voice` marker). */
+  turnHints?: Record<string, unknown>;
   /** True when the conversation was truncated (user replayed/edited a message) — engines with cached state should reset. */
   conversationReset?: boolean;
   context?: Record<string, string>;

package/src/server/ingress-router.ts

@@ -0,0 +1,90 @@
+#!/usr/bin/env bun
+// Ingress router: tiny host-header TCP router fronting shraga instances.
+// The deployment's ingress (CF Tunnel or Caddy) always points here; this process
+// routes by Host header to local ports. Previews and blue-green flips are just edits
+// to the routing file — this process never restarts during a flip (that's why it runs
+// as its own process, NOT inside the server: `flip-restart` restarts the server while
+// the router holds traffic).
+//
+//   bun run src/server/ingress-router.ts          # INGRESS_PORT (default 3100)
+//   shraga ingress                                # same, via the CLI
+//
+// Routing file (dataPath('ingress-router.json'), hot-reloaded on change):
+//   { "default": 3032, "routes": { "pr-13.preview.agent.example.com": 3850 } }
+//
+// Works at the TCP level: reads bytes until the first request's headers end, parses Host,
+// connects upstream, replays the buffered bytes, then splices both directions blindly.
+// WebSocket upgrades and keep-alive flow through untouched (same upstream per connection).
+
+import net from 'node:net';
+import { existsSync, readFileSync, watch, writeFileSync } from 'node:fs';
+import { dataPath } from './paths.ts';
+
+const PORT = Number(process.env.INGRESS_PORT) || 3100;
+const CONFIG = dataPath('ingress-router.json');
+const HEADER_LIMIT = 16 * 1024;
+
+interface Routing { default: number; routes: Record<string, number>; }
+let routing: Routing = { default: 3032, routes: {} };
+
+function loadRouting() {
+  try {
+    routing = { routes: {}, ...JSON.parse(readFileSync(CONFIG, 'utf-8')) };
+    console.log(`[ingress] routing: default→:${routing.default}, ${Object.keys(routing.routes).length} route(s)`);
+  } catch (err) {
+    console.error(`[ingress] bad routing file, keeping previous:`, (err as Error).message);
+  }
+}
+if (!existsSync(CONFIG)) writeFileSync(CONFIG, JSON.stringify(routing, null, 2));
+loadRouting();
+let reloadTimer: ReturnType<typeof setTimeout> | null = null;
+watch(CONFIG, () => { // debounce — editors fire multiple events per save
+  if (reloadTimer) clearTimeout(reloadTimer);
+  reloadTimer = setTimeout(loadRouting, 100);
+});
+
+function upstreamFor(host: string): number {
+  const bare = host.toLowerCase().split(':')[0];
+  return routing.routes[bare] ?? routing.default;
+}
+
+const server = net.createServer((client) => {
+  let buf = Buffer.alloc(0);
+  client.once('error', () => client.destroy());
+
+  const onData = (chunk: Buffer) => {
+    buf = Buffer.concat([buf, chunk]);
+    const headerEnd = buf.indexOf('\r\n\r\n');
+    if (headerEnd === -1) {
+      if (buf.length > HEADER_LIMIT) client.destroy();
+      return;
+    }
+    client.off('data', onData);
+    client.pause();
+
+    const head = buf.subarray(0, headerEnd).toString('latin1');
+    const host = /\r\nhost:\s*([^\r\n]+)/i.exec('\r\n' + head)?.[1]?.trim() ?? '';
+    const port = upstreamFor(host);
+
+    const upstream = net.connect(port, '127.0.0.1', () => {
+      client.setTimeout(0); // routed — long-lived (WS) connections idle freely
+      upstream.write(buf);
+      client.pipe(upstream);
+      upstream.pipe(client);
+      client.resume();
+    });
+    const drop = () => { client.destroy(); upstream.destroy(); };
+    upstream.on('error', (err) => {
+      console.warn(`[ingress] upstream :${port} (${host}):`, err.message);
+      if (!client.writableEnded) client.end('HTTP/1.1 502 Bad Gateway\r\ncontent-length: 0\r\nconnection: close\r\n\r\n');
+      upstream.destroy();
+    });
+    client.on('error', drop);
+    client.on('close', () => upstream.destroy());
+    upstream.on('close', () => client.destroy());
+  };
+  client.on('data', onData);
+  client.setTimeout(15_000, () => { if (!client.bytesWritten) client.destroy(); });
+});
+
+server.listen(PORT, () => console.log(`[ingress] listening on :${PORT}, routing file: ${CONFIG}`));

package/src/server/prompt-suffix.ts

@@ -0,0 +1,38 @@
+// System-prompt-suffix seam — a generic drop-in for optional add-ons to append text to the agent's
+// system prompt, decided per-turn off the opaque hints bag.
+//
+// Every turn, each engine appends whatever the registered contributors return. A contributor reads its
+// OWN keys off the opaque `turnHints` bag (the core interprets none) and returns a suffix — or '' to
+// contribute nothing. The core owns only this seam: it names no add-on concept (voice, etc.). With no
+// contributor registered (CE's own state) the suffix is '' and the assembled prompt is byte-identical
+// to before. An add-on (e.g. shraga-ee's voice feature) registers a contributor that returns its own
+// bundled suffix when its marker (e.g. `turnHints.voice`) is present.
+//
+// Sibling of `turn-context.ts` and shaped like it: typed, optional, registered before startup, a no-op
+// when nothing registers.
+
+/** Return a system-prompt suffix for this turn (trimmed by the seam), or '' to contribute nothing.
+ *  Reads its own keys off the opaque per-turn hints bag. */
+export type PromptSuffixContributor = (turnHints?: Record<string, unknown>) => string;
+
+const contributors: PromptSuffixContributor[] = [];
+
+/** Register a prompt-suffix contributor. Called by an optional add-on before startup. */
+export function registerPromptSuffix(fn: PromptSuffixContributor): void {
+  contributors.push(fn);
+}
+
+/** The combined suffix for this turn, or '' when nothing contributes. A throwing contributor is
+ *  contained (logged, skipped) so a broken add-on can't take down a turn. */
+export function getPromptSuffix(turnHints?: Record<string, unknown>): string {
+  const parts: string[] = [];
+  for (const fn of contributors) {
+    try {
+      const s = fn(turnHints)?.trim();
+      if (s) parts.push(s);
+    } catch (err) {
+      console.error('[prompt-suffix] contributor failed:', (err as Error)?.message ?? err);
+    }
+  }
+  return parts.join('\n\n');
+}

package/src/server/sessions.ts

@@ -356,6 +356,8 @@ export type ConvBlock =
   | { type: 'tool_use'; tool: string; toolUseId: string; input: unknown }
   | { type: 'tool_result'; toolUseId: string; output: string }
   | { type: 'thinking'; text: string }
+  // Persisted block written by an add-on engine's background worker (e.g. EE's duplex voice brain).
+  // The core stores/renders it but owns none of its semantics; name kept for stored-history back-compat.
   | { type: 'duplex_result'; label?: string; tier?: string; text?: string }
   | { type: 'summary'; text: string; compactedCount: number }
   | { type: 'compact_marker'; summary: string; compactedCount: number };