omnigateway 0.1.6 → 0.1.7

package/bin/omni.js

@@ -188,6 +188,23 @@ class GatewayError extends Error {
 }
 // packages/ir/src/logger.ts
 var LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };
+var ANSI2 = /\u001B\[[0-9;]*m/g;
+var HEAD = /^(\S+) (DEBUG|INFO|WARN|ERROR) {1,2}(.*)$/;
+var FIELDS = / {2}(?=[a-zA-Z]+=)/;
+function parseLine(raw) {
+  const absent = { raw, at: null, level: null, msg: null };
+  const match = HEAD.exec(raw.replace(ANSI2, ""));
+  if (match === null)
+    return absent;
+  const [, instant, label, tail] = match;
+  if (instant === undefined || label === undefined || tail === undefined)
+    return absent;
+  const at = Date.parse(instant);
+  if (Number.isNaN(at))
+    return absent;
+  const msg = tail.split(FIELDS, 1)[0] ?? tail;
+  return { raw, at, level: label.toLowerCase(), msg };
+}
 var noopLogger = {
   debug: () => {},
   info: () => {},
@@ -234,6 +251,7 @@ function loadConfig(env) {
   const derivedBaseUrl = `http://${host}:${port}`;
   const baseUrl = optionalText(env.OMNI_BASE_URL, derivedBaseUrl).replace(/\/+$/, "") || derivedBaseUrl;
   const staticDir = env.OMNI_STATIC_DIR?.trim();
+  const logFile = env.OMNI_LOG_FILE?.trim();
   const rawLogLevel = env.OMNI_LOG_LEVEL?.trim();
   const logLevel = parseLogLevel(rawLogLevel);
   return {
@@ -244,7 +262,8 @@ function loadConfig(env) {
     databasePath: optionalText(env.OMNI_DB_PATH, "./omnigateway.db"),
     encryptionKey,
     baseUrl,
-    staticDir: staticDir === undefined || staticDir.length === 0 ? null : staticDir
+    staticDir: staticDir === undefined || staticDir.length === 0 ? null : staticDir,
+    logFile: logFile === undefined || logFile.length === 0 ? null : logFile
   };
 }
 // packages/providers/src/body.ts
@@ -669,7 +688,7 @@ async function* decodeAnthropic(messages) {
         if (cb.type === "text")
           yield { type: "blockStart", index, block: { type: "text" } };
         else if (cb.type === "thinking")
-          yield { type: "blockStart", index, block: { type: "thinking" } };
+          yield { type: "blockStart", index, block: { type: "thinking", signed: true } };
         else if (cb.type === "tool_use")
           yield {
             type: "blockStart",
@@ -689,7 +708,7 @@ async function* decodeAnthropic(messages) {
             index,
             delta: { type: "thinking", text: delta.thinking ?? "" }
           };
-        else if (delta.type === "signature_delta")
+        else if (delta.type === "signature_delta" && (delta.signature ?? "") !== "")
           yield {
             type: "blockDelta",
             index,
@@ -761,6 +780,9 @@ function wireCacheControl(c) {
     return {};
   return { cache_control: { type: c.type, ...c.ttl === undefined ? {} : { ttl: c.ttl } } };
 }
+function isReplayableThinking(b) {
+  return b.type !== "thinking" || b.signature !== undefined && b.signature !== "";
+}
 function encodeBlock(b) {
   const cache = wireCacheControl(cacheControlOf(b));
   switch (b.type) {
@@ -790,6 +812,16 @@ function encodeSystemTurn(content) {
   return content.flatMap((b) => b.type === "text" ? [b.text] : []).join(`
 `);
 }
+function systemCacheControl(req) {
+  const cacheable = req.messages.flatMap((message) => message.content.flatMap((block) => block.type === "thinking" ? [] : [{ role: message.role, block }]));
+  const markedSystemBlocks = cacheable.filter(({ role, block }) => role === "system" && cacheControlOf(block) !== undefined);
+  const final = markedSystemBlocks.at(-1);
+  const promoted = final !== undefined && final.block.type === "text" && cacheable.at(-1) === final ? cacheControlOf(final.block) : undefined;
+  return {
+    ...promoted === undefined ? {} : { promoted },
+    lost: markedSystemBlocks.length > (promoted === undefined ? 0 : 1)
+  };
+}
 function encodeToolChoice(c) {
   switch (c.type) {
     case "auto":
@@ -813,18 +845,30 @@ function toWire(req, model, opts) {
     system = [{ type: "text", text: OAUTH_IDENTITY }, ...system ?? []];
     note2("anthropic:oauth-system-prefix");
   }
+  const systemCache = systemCacheControl(req);
+  if (systemCache.lost)
+    note2("anthropic:system-turn-cache-control-dropped");
   const body = {
     model,
-    messages: req.messages.map((m) => {
-      if (m.role !== "system")
-        return { role: m.role, content: m.content.map(encodeBlock) };
-      if (m.content.some((b) => cacheControlOf(b) !== undefined)) {
-        note2("anthropic:system-turn-cache-control-dropped");
-      }
-      return { role: m.role, content: encodeSystemTurn(m.content) };
+    messages: req.messages.flatMap((m) => {
+      if (m.role !== "system") {
+        const replayable = m.content.filter(isReplayableThinking);
+        if (replayable.length !== m.content.length)
+          note2("anthropic:unsigned-thinking-dropped");
+        if (replayable.length === 0)
+          return [];
+        return [{ role: m.role, content: replayable.map(encodeBlock) }];
+      }
+      return [{ role: m.role, content: encodeSystemTurn(m.content) }];
     }),
     max_tokens: req.maxTokens ?? 4096,
-    stream: req.stream
+    stream: req.stream,
+    ...systemCache.promoted === undefined ? {} : {
+      cache_control: {
+        type: systemCache.promoted.type,
+        ...systemCache.promoted.ttl === undefined ? {} : { ttl: systemCache.promoted.ttl }
+      }
+    }
   };
   if (system !== undefined && system.length > 0)
     body.system = system;
@@ -2181,6 +2225,62 @@ function createConnectFlows(deps) {
     }
   };
 }
+// packages/control/src/console.ts
+var UNIT_NAME = "omnigateway.service";
+var MAX_CONSOLE_LINES = 500;
+var DEFAULT_CONSOLE_LINES = 200;
+function resolveConsoleSource(input) {
+  const path = input.logFile?.trim();
+  if (path !== undefined && path.length > 0)
+    return { kind: "file", path };
+  if (input.unitInstalled)
+    return { kind: "journal", unit: UNIT_NAME, scope: input.scope };
+  return { kind: "none" };
+}
+function consoleLimit(requested) {
+  const value = requested === undefined ? DEFAULT_CONSOLE_LINES : Number(requested);
+  if (!Number.isFinite(value))
+    return DEFAULT_CONSOLE_LINES;
+  return Math.floor(Math.min(Math.max(1, value), MAX_CONSOLE_LINES));
+}
+function keep(line, query) {
+  if (query.since !== undefined && (line.at === null || line.at <= query.since))
+    return false;
+  if (query.level === undefined || line.level === null)
+    return true;
+  return LEVELS[line.level] >= LEVELS[query.level];
+}
+var SCAN_FACTOR = 20;
+var SCAN_LIMIT = 5000;
+function scanWidth(query) {
+  const filtered = query.level !== undefined || query.since !== undefined;
+  return filtered ? Math.min(query.lines * SCAN_FACTOR, SCAN_LIMIT) : query.lines;
+}
+async function readSource(deps, source, lines) {
+  if (source.kind === "none")
+    return "";
+  if (source.kind === "file")
+    return deps.readFile(source.path, lines) ?? "";
+  const scope = source.scope === "system" ? [] : ["--user"];
+  const result = await deps.run([
+    "journalctl",
+    ...scope,
+    "-u",
+    source.unit,
+    "-n",
+    String(lines),
+    "--no-pager",
+    "--output=cat"
+  ]);
+  return result.code === 0 ? result.stdout : "";
+}
+async function readConsole(deps, source, query) {
+  const limited = { ...query, lines: consoleLimit(query.lines) };
+  const text = await readSource(deps, source, scanWidth(limited));
+  const lines = text.split(`
+`).filter((raw) => raw.trim().length > 0).map(parseLine).filter((line) => keep(line, limited)).slice(-limited.lines);
+  return source.kind === "file" ? { source: "file", path: source.path, lines } : { source: source.kind, lines };
+}
 // node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -18241,6 +18341,50 @@ async function putSettings(store, input) {
   await store.config.putSettings(settings);
   return settings;
 }
+// packages/control/src/tail.ts
+import { closeSync, fstatSync, openSync, readSync, statSync } from "fs";
+var CHUNK = 64 * 1024;
+var MAX_BYTES = 8 * 1024 * 1024;
+function tailFile(path, lines) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const size = fstatSync(fd).size;
+    if (size === 0)
+      return "";
+    const budget = Math.min(size, MAX_BYTES);
+    let read = 0;
+    let newlines = 0;
+    const chunks = [];
+    while (read < budget && newlines <= lines) {
+      const span = Math.min(CHUNK, budget - read);
+      const buffer = Buffer.allocUnsafe(span);
+      const position = size - read - span;
+      readSync(fd, buffer, 0, span, position);
+      chunks.unshift(buffer);
+      read += span;
+      for (const byte of buffer)
+        if (byte === 10)
+          newlines++;
+    }
+    return Buffer.concat(chunks).toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    closeSync(fd);
+  }
+}
+function fileExists(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
 // packages/control/src/usage.ts
 var MAX_LOG_LIMIT = 500;
 var DEFAULT_LOG_LIMIT = 100;
@@ -18475,6 +18619,278 @@ async function pollUntilAuthorized(flows, start, deps) {
   }
 }
 
+// apps/cli/src/service.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+var UNIT_NAME2 = "omnigateway.service";
+function unitPath(scope) {
+  return scope === "system" ? join2("/etc/systemd/system", UNIT_NAME2) : join2(homedir2(), ".config", "systemd", "user", UNIT_NAME2);
+}
+function systemctlArgs(scope, args) {
+  return scope === "system" ? ["systemctl", ...args] : ["systemctl", "--user", ...args];
+}
+function pidFile(stateDir) {
+  return join2(stateDir, "gateway.pid");
+}
+function logFile(stateDir) {
+  return join2(stateDir, "gateway.log");
+}
+function supervisedLogFile(deps) {
+  const configured = deps.logFile?.trim();
+  return configured !== undefined && configured.length > 0 ? configured : logFile(deps.stateDir);
+}
+function defaultStateDir(env2) {
+  const xdg = env2.XDG_STATE_HOME;
+  const base = typeof xdg === "string" && xdg.length > 0 ? xdg : join2(homedir2(), ".local", "state");
+  return join2(base, "omnigateway");
+}
+function unitFile(input) {
+  return `[Unit]
+Description=${input.description ?? "OmniGateway"}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory=${input.root}
+EnvironmentFile=${join2(input.root, ".env")}
+ExecStart=${input.bun} ${input.entrypoint}
+Restart=on-failure
+RestartSec=2
+
+[Install]
+WantedBy=default.target
+`;
+}
+function unitInstalled(deps) {
+  return existsSync2(deps.unitPath);
+}
+function readPid(stateDir) {
+  const file2 = pidFile(stateDir);
+  if (!existsSync2(file2))
+    return null;
+  const pid = Number(readFileSync2(file2, "utf8").trim());
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function livePid(deps) {
+  const pid = readPid(deps.stateDir);
+  if (pid === null)
+    return null;
+  if (deps.alive(pid))
+    return pid;
+  rmSync(pidFile(deps.stateDir), { force: true });
+  return null;
+}
+async function status(deps) {
+  if (unitInstalled(deps)) {
+    const active = await deps.run(systemctlArgs(deps.scope, ["is-active", UNIT_NAME2]));
+    const state = active.stdout.trim() || active.stderr.trim() || "unknown";
+    const shown = await deps.run(systemctlArgs(deps.scope, ["show", UNIT_NAME2, "--property=MainPID", "--value"]));
+    const pid2 = Number(shown.stdout.trim());
+    return {
+      supervisor: "systemd",
+      running: state === "active",
+      pid: Number.isInteger(pid2) && pid2 > 0 ? pid2 : null,
+      state,
+      unitPath: deps.unitPath,
+      logFile: null
+    };
+  }
+  const pid = livePid(deps);
+  return {
+    supervisor: pid === null ? "none" : "pidfile",
+    running: pid !== null,
+    pid,
+    state: null,
+    unitPath: null,
+    logFile: supervisedLogFile(deps)
+  };
+}
+async function start(deps, input) {
+  if (unitInstalled(deps)) {
+    const result = await deps.run(systemctlArgs(deps.scope, ["start", UNIT_NAME2]));
+    if (result.code !== 0) {
+      throw new Error(result.stderr.trim() || `systemctl start exited ${result.code}`);
+    }
+    return {
+      supervisor: "systemd",
+      pid: null,
+      healthy: await waitForHealth(deps, input.baseUrl)
+    };
+  }
+  const running = livePid(deps);
+  if (running !== null) {
+    return {
+      supervisor: "pidfile",
+      pid: running,
+      healthy: await waitForHealth(deps, input.baseUrl)
+    };
+  }
+  mkdirSync(deps.stateDir, { recursive: true });
+  const file2 = supervisedLogFile(deps);
+  mkdirSync(dirname(file2), { recursive: true });
+  const pid = deps.spawn({
+    argv: input.argv,
+    cwd: deps.root,
+    env: { ...input.env, OMNI_LOG_FILE: file2 },
+    logFile: file2
+  });
+  writeFileSync(pidFile(deps.stateDir), `${pid}
+`);
+  return { supervisor: "pidfile", pid, healthy: await waitForHealth(deps, input.baseUrl) };
+}
+var HEALTH_TIMEOUT_MS = 1e4;
+var HEALTH_INTERVAL_MS = 200;
+async function waitForHealth(deps, baseUrl) {
+  const attempts = Math.ceil(HEALTH_TIMEOUT_MS / HEALTH_INTERVAL_MS);
+  for (let attempt = 0;attempt < attempts; attempt++) {
+    if (await deps.probe(baseUrl))
+      return true;
+    await deps.sleep(HEALTH_INTERVAL_MS);
+  }
+  return false;
+}
+var STOP_GRACE_MS = 5000;
+var STOP_INTERVAL_MS = 100;
+async function stop(deps) {
+  if (unitInstalled(deps)) {
+    const result = await deps.run(systemctlArgs(deps.scope, ["stop", UNIT_NAME2]));
+    if (result.code !== 0) {
+      throw new Error(result.stderr.trim() || `systemctl stop exited ${result.code}`);
+    }
+    return { supervisor: "systemd", stopped: true };
+  }
+  const pid = livePid(deps);
+  if (pid === null)
+    return { supervisor: "none", stopped: false };
+  deps.kill(pid, "SIGTERM");
+  const attempts = Math.ceil(STOP_GRACE_MS / STOP_INTERVAL_MS);
+  for (let attempt = 0;deps.alive(pid); attempt++) {
+    if (attempt >= attempts) {
+      deps.kill(pid, "SIGKILL");
+      break;
+    }
+    await deps.sleep(STOP_INTERVAL_MS);
+  }
+  rmSync(pidFile(deps.stateDir), { force: true });
+  return { supervisor: "pidfile", stopped: true };
+}
+async function install(deps, input) {
+  const path = deps.unitPath;
+  if (existsSync2(path) && !input.force) {
+    throw new Error(`${path} already exists; pass --force to replace it`);
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, unitFile({ root: deps.root, bun: input.bun, entrypoint: input.entrypoint }));
+  const reload = await deps.run(systemctlArgs(deps.scope, ["daemon-reload"]));
+  let enabled = false;
+  if (input.enable) {
+    const result = await deps.run(systemctlArgs(deps.scope, ["enable", UNIT_NAME2]));
+    enabled = result.code === 0;
+  }
+  return { path, reloaded: reload.code === 0, enabled };
+}
+async function uninstall(deps) {
+  const path = deps.unitPath;
+  if (!existsSync2(path))
+    return { path, removed: false };
+  await deps.run(systemctlArgs(deps.scope, ["disable", "--now", UNIT_NAME2]));
+  rmSync(path, { force: true });
+  await deps.run(systemctlArgs(deps.scope, ["daemon-reload"]));
+  return { path, removed: true };
+}
+function consoleSource(deps) {
+  const configured = deps.logFile?.trim();
+  const chosen = configured !== undefined && configured.length > 0 && fileExists(configured) ? configured : unitInstalled(deps) ? undefined : fileExists(supervisedLogFile(deps)) ? supervisedLogFile(deps) : undefined;
+  return {
+    source: resolveConsoleSource({
+      ...chosen === undefined ? {} : { logFile: chosen },
+      unitInstalled: unitInstalled(deps),
+      scope: deps.scope
+    }),
+    deps: {
+      readFile: (path, lines) => tailFile(path, lines),
+      run: deps.run
+    }
+  };
+}
+async function serviceLogs(deps, lines) {
+  const { source, deps: readDeps } = consoleSource(deps);
+  const read = await readConsole(readDeps, source, { lines });
+  return read.lines.map((line) => line.raw).join(`
+`);
+}
+
+// apps/cli/src/commands/console.ts
+var FOLLOW_INTERVAL_MS = 2000;
+var LEVEL_TONE = {
+  debug: "dim",
+  warn: "yellow",
+  error: "red"
+};
+function render(ctx, lines) {
+  return lines.map((line) => {
+    const tone = line.level === null ? undefined : LEVEL_TONE[line.level];
+    return tone === undefined ? line.raw : paint(ctx, tone, line.raw);
+  }).join(`
+`);
+}
+function sourceHint(source) {
+  if (source.kind === "file")
+    return `${source.path} (named by OMNI_LOG_FILE)`;
+  if (source.kind === "journal")
+    return `systemd journal for ${source.unit}`;
+  return "not captured \u2014 run under systemd, or start it with `omni start`";
+}
+function empty(source) {
+  if (source.kind !== "none")
+    return `no output yet in ${sourceHint(source)}`;
+  return [
+    "this gateway's output is not being captured, so there is nothing to show.",
+    "run it in the foreground and its output goes to your terminal instead.",
+    "to capture it: `omni service install`, or `omni start`, which redirects",
+    "output to a file and points OMNI_LOG_FILE at it."
+  ].join(`
+`);
+}
+var console_ = {
+  usage: "console [-n N] [--follow] [--level debug|info|warn|error]",
+  summary: "Show the gateway process's own output",
+  options: {
+    number: { type: "string", short: "n" },
+    follow: { type: "boolean" },
+    level: { type: "string" },
+    system: { type: "boolean" }
+  },
+  async run(args, { ctx, writer, service }) {
+    const lines = numberFlag(args.values, "number") ?? 50;
+    const rawLevel = stringFlag(args.values, "level");
+    const level = parseLogLevel(rawLevel);
+    if (rawLevel !== undefined && level === null) {
+      throw new UsageError(`unknown level "${rawLevel}"; use debug, info, warn or error`);
+    }
+    const { source, deps } = consoleSource(service());
+    const query = { lines, ...level === null ? {} : { level } };
+    const first = await readConsole(deps, source, query);
+    emit(ctx, writer, first, () => first.lines.length === 0 ? empty(source) : render(ctx, first.lines));
+    if (!ctx.json && first.lines.length > 0) {
+      note(ctx, writer, paint(ctx, "dim", `reading ${sourceHint(source)}`));
+    }
+    if (boolFlag(args.values, "follow") !== true || ctx.json)
+      return;
+    let seen = first.lines.at(-1)?.at ?? 0;
+    for (;; ) {
+      await Bun.sleep(FOLLOW_INTERVAL_MS);
+      const next = await readConsole(deps, source, { ...query, since: seen });
+      if (next.lines.length === 0)
+        continue;
+      seen = next.lines.at(-1)?.at ?? seen;
+      writer.out(render(ctx, next.lines));
+    }
+  }
+};
+
 // apps/cli/src/command.ts
 var PROVIDER_TONE = {
   anthropic: "magenta",
@@ -18515,7 +18931,7 @@ var credentialsList = {
         { header: "STATE" },
         { header: "EXPIRES" }
       ], credentials.map((c) => {
-        const status = condition(c);
+        const status2 = condition(c);
         return [
           c.id,
           provider(ctx, c.provider),
@@ -18523,7 +18939,7 @@ var credentialsList = {
           c.authType,
           String(c.tier),
           String(c.weight),
-          state(ctx, status.ok, status.text),
+          state(ctx, status2.ok, status2.text),
           formatTime(c.expiresAt)
         ];
       }));
@@ -18539,7 +18955,7 @@ var credentialsShow = {
   async run(args, { ctx, writer }) {
     const id = requirePositional(args, 0, "credential id");
     const credential = await findCredential(ctx, id);
-    const status = condition(credential);
+    const status2 = condition(credential);
     const data = {
       id: credential.id,
       provider: credential.provider,
@@ -18562,7 +18978,7 @@ var credentialsShow = {
       ["provider", provider(ctx, credential.provider)],
       ["label", credential.label],
       ["auth", credential.authType],
-      ["state", state(ctx, status.ok, status.text)],
+      ["state", state(ctx, status2.ok, status2.text)],
       ["tier", String(credential.tier)],
       ["weight", String(credential.weight)],
       ["account", credential.accountEmail ?? "\u2014"],
@@ -18697,12 +19113,12 @@ var credentialsHealth = {
 };
 
 // apps/cli/src/commands/db.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 var dbMigrate = {
   usage: "db migrate",
   summary: "Create or upgrade the database schema",
   async run(_args, { ctx, writer }) {
-    const existed = existsSync2(ctx.databasePath);
+    const existed = existsSync3(ctx.databasePath);
     const store = await ctx.store();
     await store.config.getSettings();
     emit(ctx, writer, { path: ctx.databasePath, created: !existed }, () => fields([
@@ -19030,207 +19446,8 @@ ${candidates}${excluded}`;
 import { existsSync as existsSync5 } from "fs";
 
 // apps/cli/src/runtime.ts
-import { closeSync, existsSync as existsSync4, openSync } from "fs";
+import { closeSync as closeSync2, existsSync as existsSync4, openSync as openSync2 } from "fs";
 import { join as join3 } from "path";
-
-// apps/cli/src/service.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname, join as join2 } from "path";
-var UNIT_NAME = "omnigateway.service";
-function unitPath(scope) {
-  return scope === "system" ? join2("/etc/systemd/system", UNIT_NAME) : join2(homedir2(), ".config", "systemd", "user", UNIT_NAME);
-}
-function systemctlArgs(scope, args) {
-  return scope === "system" ? ["systemctl", ...args] : ["systemctl", "--user", ...args];
-}
-function pidFile(stateDir) {
-  return join2(stateDir, "gateway.pid");
-}
-function logFile(stateDir) {
-  return join2(stateDir, "gateway.log");
-}
-function defaultStateDir(env2) {
-  const xdg = env2.XDG_STATE_HOME;
-  const base = typeof xdg === "string" && xdg.length > 0 ? xdg : join2(homedir2(), ".local", "state");
-  return join2(base, "omnigateway");
-}
-function unitFile(input) {
-  return `[Unit]
-Description=${input.description ?? "OmniGateway"}
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-WorkingDirectory=${input.root}
-EnvironmentFile=${join2(input.root, ".env")}
-ExecStart=${input.bun} ${input.entrypoint}
-Restart=on-failure
-RestartSec=2
-
-[Install]
-WantedBy=default.target
-`;
-}
-function unitInstalled(deps) {
-  return existsSync3(deps.unitPath);
-}
-function readPid(stateDir) {
-  const file2 = pidFile(stateDir);
-  if (!existsSync3(file2))
-    return null;
-  const pid = Number(readFileSync2(file2, "utf8").trim());
-  return Number.isInteger(pid) && pid > 0 ? pid : null;
-}
-function livePid(deps) {
-  const pid = readPid(deps.stateDir);
-  if (pid === null)
-    return null;
-  if (deps.alive(pid))
-    return pid;
-  rmSync(pidFile(deps.stateDir), { force: true });
-  return null;
-}
-async function status(deps) {
-  if (unitInstalled(deps)) {
-    const active = await deps.run(systemctlArgs(deps.scope, ["is-active", UNIT_NAME]));
-    const state2 = active.stdout.trim() || active.stderr.trim() || "unknown";
-    const shown = await deps.run(systemctlArgs(deps.scope, ["show", UNIT_NAME, "--property=MainPID", "--value"]));
-    const pid2 = Number(shown.stdout.trim());
-    return {
-      supervisor: "systemd",
-      running: state2 === "active",
-      pid: Number.isInteger(pid2) && pid2 > 0 ? pid2 : null,
-      state: state2,
-      unitPath: deps.unitPath,
-      logFile: null
-    };
-  }
-  const pid = livePid(deps);
-  return {
-    supervisor: pid === null ? "none" : "pidfile",
-    running: pid !== null,
-    pid,
-    state: null,
-    unitPath: null,
-    logFile: logFile(deps.stateDir)
-  };
-}
-async function start(deps, input) {
-  if (unitInstalled(deps)) {
-    const result = await deps.run(systemctlArgs(deps.scope, ["start", UNIT_NAME]));
-    if (result.code !== 0) {
-      throw new Error(result.stderr.trim() || `systemctl start exited ${result.code}`);
-    }
-    return {
-      supervisor: "systemd",
-      pid: null,
-      healthy: await waitForHealth(deps, input.baseUrl)
-    };
-  }
-  const running = livePid(deps);
-  if (running !== null) {
-    return {
-      supervisor: "pidfile",
-      pid: running,
-      healthy: await waitForHealth(deps, input.baseUrl)
-    };
-  }
-  mkdirSync(deps.stateDir, { recursive: true });
-  const pid = deps.spawn({
-    argv: input.argv,
-    cwd: deps.root,
-    env: input.env,
-    logFile: logFile(deps.stateDir)
-  });
-  writeFileSync(pidFile(deps.stateDir), `${pid}
-`);
-  return { supervisor: "pidfile", pid, healthy: await waitForHealth(deps, input.baseUrl) };
-}
-var HEALTH_TIMEOUT_MS = 1e4;
-var HEALTH_INTERVAL_MS = 200;
-async function waitForHealth(deps, baseUrl) {
-  const attempts = Math.ceil(HEALTH_TIMEOUT_MS / HEALTH_INTERVAL_MS);
-  for (let attempt = 0;attempt < attempts; attempt++) {
-    if (await deps.probe(baseUrl))
-      return true;
-    await deps.sleep(HEALTH_INTERVAL_MS);
-  }
-  return false;
-}
-var STOP_GRACE_MS = 5000;
-var STOP_INTERVAL_MS = 100;
-async function stop(deps) {
-  if (unitInstalled(deps)) {
-    const result = await deps.run(systemctlArgs(deps.scope, ["stop", UNIT_NAME]));
-    if (result.code !== 0) {
-      throw new Error(result.stderr.trim() || `systemctl stop exited ${result.code}`);
-    }
-    return { supervisor: "systemd", stopped: true };
-  }
-  const pid = livePid(deps);
-  if (pid === null)
-    return { supervisor: "none", stopped: false };
-  deps.kill(pid, "SIGTERM");
-  const attempts = Math.ceil(STOP_GRACE_MS / STOP_INTERVAL_MS);
-  for (let attempt = 0;deps.alive(pid); attempt++) {
-    if (attempt >= attempts) {
-      deps.kill(pid, "SIGKILL");
-      break;
-    }
-    await deps.sleep(STOP_INTERVAL_MS);
-  }
-  rmSync(pidFile(deps.stateDir), { force: true });
-  return { supervisor: "pidfile", stopped: true };
-}
-async function install(deps, input) {
-  const path = deps.unitPath;
-  if (existsSync3(path) && !input.force) {
-    throw new Error(`${path} already exists; pass --force to replace it`);
-  }
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, unitFile({ root: deps.root, bun: input.bun, entrypoint: input.entrypoint }));
-  const reload = await deps.run(systemctlArgs(deps.scope, ["daemon-reload"]));
-  let enabled = false;
-  if (input.enable) {
-    const result = await deps.run(systemctlArgs(deps.scope, ["enable", UNIT_NAME]));
-    enabled = result.code === 0;
-  }
-  return { path, reloaded: reload.code === 0, enabled };
-}
-async function uninstall(deps) {
-  const path = deps.unitPath;
-  if (!existsSync3(path))
-    return { path, removed: false };
-  await deps.run(systemctlArgs(deps.scope, ["disable", "--now", UNIT_NAME]));
-  rmSync(path, { force: true });
-  await deps.run(systemctlArgs(deps.scope, ["daemon-reload"]));
-  return { path, removed: true };
-}
-async function serviceLogs(deps, lines) {
-  if (unitInstalled(deps)) {
-    const args = deps.scope === "system" ? [] : ["--user"];
-    const result = await deps.run([
-      "journalctl",
-      ...args,
-      "-u",
-      UNIT_NAME,
-      "-n",
-      String(lines),
-      "--no-pager"
-    ]);
-    return result.stdout.trimEnd();
-  }
-  const file2 = logFile(deps.stateDir);
-  if (!existsSync3(file2))
-    return "";
-  return readFileSync2(file2, "utf8").split(`
-`).slice(-lines).join(`
-`).trimEnd();
-}
-
-// apps/cli/src/runtime.ts
 var runCommand = async (argv) => {
   const proc = Bun.spawn([...argv], { stdout: "pipe", stderr: "pipe" });
   const [stdout, stderr, code] = await Promise.all([
@@ -19241,7 +19458,7 @@ var runCommand = async (argv) => {
   return { code, stdout, stderr };
 };
 var spawnDetached = ({ argv, cwd, env: env2, logFile: logFile2 }) => {
-  const fd = openSync(logFile2, "a");
+  const fd = openSync2(logFile2, "a");
   try {
     const proc = Bun.spawn([...argv], {
       cwd,
@@ -19253,7 +19470,7 @@ var spawnDetached = ({ argv, cwd, env: env2, logFile: logFile2 }) => {
     proc.unref();
     return proc.pid;
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 };
 async function runForeground(input) {
@@ -19294,11 +19511,13 @@ function gatewayEntrypoint(root, cliDir = import.meta.dir) {
   return candidates.find((path) => existsSync4(path)) ?? null;
 }
 function createServiceDeps(input) {
+  const logFile2 = input.env.OMNI_LOG_FILE?.trim();
   return {
     root: input.root,
     stateDir: defaultStateDir(input.env),
     scope: input.scope,
     unitPath: unitPath(input.scope),
+    ...logFile2 === undefined || logFile2.length === 0 ? {} : { logFile: logFile2 },
     run: runCommand,
     spawn: spawnDetached,
     probe: probeHealth,
@@ -19341,7 +19560,7 @@ var start2 = {
     emit(ctx, writer, result, () => {
       const how = result.supervisor === "systemd" ? "systemd" : `pid ${result.pid}`;
       if (!result.healthy) {
-        const where = result.supervisor === "systemd" ? "journalctl -u omnigateway.service" : logFile(deps.stateDir);
+        const where = result.supervisor === "systemd" ? "journalctl -u omnigateway.service" : supervisedLogFile(deps);
         return `${state(ctx, false, "started but /health never answered")} (${how}); see ${where}`;
       }
       return `${state(ctx, true, "running")} (${how}) at ${baseUrl}`;
@@ -19434,7 +19653,8 @@ var doctor = {
       gatewayEntrypoint: gatewayEntrypoint(deps.root),
       unitInstalled: unit,
       supervisor: status2.supervisor,
-      running: status2.running
+      running: status2.running,
+      consoleSource: consoleSource(deps).source
     };
     emit(ctx, writer, checks3, () => {
       const ok = (value, text) => state(ctx, value, text);
@@ -19449,7 +19669,8 @@ var doctor = {
         ["config", checks3.configError === null ? ok(true, "ok") : ok(false, checks3.configError)],
         ["entrypoint", checks3.gatewayEntrypoint ?? ok(false, "not found")],
         ["systemd unit", unit ? deps.scope : paint(ctx, "dim", "none")],
-        ["gateway", ok(status2.running, status2.running ? "running" : "stopped")]
+        ["gateway", ok(status2.running, status2.running ? "running" : "stopped")],
+        ["console log", sourceHint(checks3.consoleSource)]
       ]);
     });
   }
@@ -19653,11 +19874,12 @@ var usage = {
 };
 var logs = {
   usage: "logs [-n N] [--follow] [--service]",
-  summary: "Show recent requests, or the gateway process's own output",
+  summary: "Show recent requests (--service is an alias for `omni console`)",
   options: {
     number: { type: "string", short: "n" },
     follow: { type: "boolean" },
-    service: { type: "boolean" }
+    service: { type: "boolean" },
+    system: { type: "boolean" }
   },
   async run(args, { ctx, writer, service }) {
     const limit = numberFlag(args.values, "number") ?? 20;
@@ -19667,7 +19889,7 @@ var logs = {
       return;
     }
     const store = await ctx.store();
-    const render = (rows) => table([
+    const render2 = (rows) => table([
       { header: "AT" },
       { header: "MODEL" },
       { header: "RESOLVED" },
@@ -19685,7 +19907,7 @@ var logs = {
       String(row.durationMs)
     ]));
     const first = await recentLogs(store, limit);
-    emit(ctx, writer, { logs: first }, () => first.length === 0 ? "no requests logged yet" : render(first));
+    emit(ctx, writer, { logs: first }, () => first.length === 0 ? "no requests logged yet" : render2(first));
     if (args.values.follow !== true || ctx.json)
       return;
     let seen = first[0]?.at ?? 0;
@@ -19695,7 +19917,7 @@ var logs = {
       if (next.length === 0)
         continue;
       seen = next[0]?.at ?? seen;
-      writer.out(render(next.reverse()));
+      writer.out(render2(next.reverse()));
     }
   }
 };
@@ -19708,6 +19930,7 @@ var COMMANDS = {
   restart,
   doctor,
   logs,
+  console: console_,
   usage,
   connect,
   "service install": serviceInstall,
@@ -19770,7 +19993,10 @@ function resolveCommand(argv) {
 
 // apps/cli/src/help.ts
 var GROUPS = [
-  { title: "Gateway", prefixes: ["status", "start", "stop", "restart", "doctor", "logs"] },
+  {
+    title: "Gateway",
+    prefixes: ["status", "start", "stop", "restart", "doctor", "logs", "console"]
+  },
   { title: "Service", prefixes: ["service "] },
   { title: "Accounts", prefixes: ["connect", "credentials "] },
   { title: "Models", prefixes: ["models "] },