niahere 0.3.12 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.3.12",
+  "version": "0.4.1",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {

package/src/agent/backends/claude-normalize.ts

@@ -0,0 +1,142 @@
+import type { AgentEvent, Normalizer } from "../types";
+import { truncate, formatToolUse } from "../../utils/format-activity";
+import { isRetryableApiError, isProviderDownError } from "../../utils/retry";
+
+/**
+ * Pure reducer: Claude Agent SDK messages → normalized `AgentEvent`s.
+ *
+ * Ports the consume-loop handling that lived inline in `engine.ts` and
+ * `runner.ts`, so the two paths share one implementation. Holds only the
+ * thinking-accumulation state those loops kept as locals. No I/O, no timers —
+ * the session that drives it owns all orchestration.
+ *
+ * Display strings (truncation, `formatToolUse`, the `$ ` Bash prefix) are
+ * produced here so behavior is byte-identical to the old loops and consumers
+ * stay backend-agnostic.
+ */
+export class SdkNormalizer implements Normalizer {
+  private accumulatedThinking = "";
+  private lastThinkingLine = "";
+
+  consume(message: unknown): AgentEvent[] {
+    const msg = message as any;
+
+    if (msg.type === "system" && msg.subtype === "init") {
+      return [{ type: "session", backendSessionId: msg.session_id }];
+    }
+
+    if (msg.type === "stream_event") {
+      return this.consumeStreamEvent(msg.event);
+    }
+
+    if (msg.type === "tool_use_summary") {
+      return [
+        {
+          type: "tool",
+          name: msg.tool_name || "tool",
+          summary: formatToolUse(msg.tool_name || "tool", msg.tool_input),
+        },
+      ];
+    }
+
+    if (msg.type === "tool_progress") {
+      if (msg.tool_name === "Bash" && msg.content) {
+        return [{ type: "tool", name: "Bash", summary: `$ ${truncate(msg.content, 60)}` }];
+      }
+      if (msg.content) {
+        return [{ type: "tool", name: msg.tool_name || "tool", summary: truncate(msg.content, 70) }];
+      }
+      return [];
+    }
+
+    if (msg.type === "system") {
+      // Subagent/task lifecycle (subtype init handled above).
+      if (msg.subtype === "task_started" && msg.description) {
+        return [{ type: "tool", name: "task", summary: truncate(msg.description, 60) }];
+      }
+      if (msg.subtype === "task_progress" && msg.last_tool_name) {
+        return [{ type: "tool", name: msg.last_tool_name, summary: msg.summary || msg.last_tool_name }];
+      }
+      return [];
+    }
+
+    if (msg.type === "result") {
+      return [this.consumeResult(msg)];
+    }
+
+    return [];
+  }
+
+  private consumeStreamEvent(event: any): AgentEvent[] {
+    if (event?.type === "content_block_delta") {
+      const delta = event.delta;
+      if (delta?.type === "text_delta" && delta.text) {
+        return [{ type: "text", delta: delta.text }];
+      }
+      if (delta?.type === "thinking_delta" && delta.thinking) {
+        return this.consumeThinkingDelta(delta.thinking);
+      }
+      return [];
+    }
+    if (event?.type === "content_block_start" && event.content_block?.type === "thinking") {
+      this.accumulatedThinking = "";
+      this.lastThinkingLine = "";
+      return [{ type: "thinking", delta: "thinking..." }];
+    }
+    if (event?.type === "content_block_stop") {
+      this.accumulatedThinking = "";
+      this.lastThinkingLine = "";
+      return [];
+    }
+    return [];
+  }
+
+  /** Emit a thinking line only on a newline boundary (the last COMPLETE line). */
+  private consumeThinkingDelta(thinking: string): AgentEvent[] {
+    this.accumulatedThinking += thinking;
+    const lines = this.accumulatedThinking.split("\n");
+    if (lines.length > 1) {
+      const completeLine = lines[lines.length - 2]?.trim();
+      if (completeLine && completeLine !== this.lastThinkingLine) {
+        this.lastThinkingLine = completeLine;
+        return [{ type: "thinking", delta: truncate(completeLine, 70) }];
+      }
+    }
+    return [];
+  }
+
+  private consumeResult(msg: any): AgentEvent {
+    if (!msg.is_error) {
+      return {
+        type: "result",
+        text: (msg.result as string) || "",
+        usage: { costUsd: msg.total_cost_usd ?? 0, turns: msg.num_turns ?? 0 },
+        backendSessionId: msg.session_id ?? "",
+        terminalReason: msg.terminal_reason,
+        metadata: {
+          cost_usd: msg.total_cost_usd,
+          turns: msg.num_turns,
+          duration_ms: msg.duration_ms,
+          duration_api_ms: msg.duration_api_ms,
+          stop_reason: msg.stop_reason,
+          terminal_reason: msg.terminal_reason,
+          session_id: msg.session_id,
+          subtype: msg.subtype,
+          usage: msg.usage,
+          model_usage: msg.modelUsage,
+        },
+      };
+    }
+    const raw = (msg.errors?.join(", ") as string) || "unknown error";
+    // Two INDEPENDENT predicates from the same raw string:
+    //  - retryable: transient API failure → the session may retry internally.
+    //  - providerDown: blank/"unknown error" → the provider is down → failover.
+    return {
+      type: "error",
+      message: raw,
+      retryable: isRetryableApiError(raw),
+      providerDown: isProviderDownError(raw),
+      terminalReason: msg.terminal_reason,
+    };
+  }
+}

package/src/agent/backends/claude.ts

@@ -0,0 +1,181 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { AgentBackend, AgentSession, AgentSessionContext, AgentEvent } from "../types";
+import type { Attachment } from "../../types/attachment";
+import { SdkNormalizer } from "./claude-normalize";
+import { MessageStream } from "../message-stream";
+import { getSdkSkillsSetting } from "../../core/skills";
+import { getSdkHooks } from "../../core/sdk-hooks";
+import { getConfig } from "../../utils/config";
+import { sleep } from "../../utils/retry";
+
+/** The shape of the SDK `query()` handle the session consumes. Injected so the
+ *  session is unit-testable without spawning Claude. */
+export type QueryHandle = AsyncIterable<unknown> & { close(): void };
+export type QueryFn = (args: { prompt: unknown; options: unknown }) => QueryHandle;
+
+const MAX_SEND_RETRIES = 2;
+const DEFAULT_RETRY_DELAYS = [3_000, 8_000];
+
+/** The SDK persists sessions at ~/.claude/projects/<encoded-cwd>/<id>.jsonl. */
+function sessionFileExists(sessionId: string, cwd: string): boolean {
+  const encoded = cwd.replace(/\//g, "-");
+  return existsSync(join(homedir(), ".claude", "projects", encoded, `${sessionId}.jsonl`));
+}
+
+/** Resolve a context/config model to the SDK's `model` option ("default" → unset). */
+export function resolveSdkModel(model?: string | null): string | undefined {
+  const m = model || getConfig().model;
+  return m && m !== "default" ? m : undefined;
+}
+
+export class ClaudeBackend implements AgentBackend {
+  readonly name = "claude" as const;
+  private queryFn: QueryFn;
+
+  constructor(deps?: { queryFn?: QueryFn }) {
+    this.queryFn = deps?.queryFn ?? (query as unknown as QueryFn);
+  }
+
+  async openSession(ctx: AgentSessionContext): Promise<AgentSession> {
+    return new ClaudeSession(ctx, this.queryFn);
+  }
+
+  async canResume(backendSessionId: string, cwd: string): Promise<boolean> {
+    return sessionFileExists(backendSessionId, cwd);
+  }
+}
+
+/**
+ * A warm Claude session: one `query()` subprocess + `MessageStream` reused
+ * across turns (the latency optimization). Each `send()` pushes a turn and
+ * yields its normalized events until a terminal `result`/`error`.
+ *
+ * Invariants (from the plan review):
+ *  - exactly ONE `session` event per `send()`, even across an internal retry
+ *    (a retry resumes the same session id, so the post-retry init is swallowed);
+ *  - retry teardown+restart is internal and atomic w.r.t. `abort()`.
+ */
+class ClaudeSession implements AgentSession {
+  private _sessionId: string | null;
+  private handle: QueryHandle | null = null;
+  private iterator: AsyncIterator<unknown> | null = null;
+  private stream: MessageStream | null = null;
+  private aborted: string | null = null;
+  private retryCount = 0;
+  private readonly retryDelays: number[];
+
+  constructor(
+    private ctx: AgentSessionContext & { retryDelaysMs?: number[] },
+    private queryFn: QueryFn,
+  ) {
+    this._sessionId = typeof ctx.resume === "string" ? ctx.resume : null;
+    this.retryDelays = ctx.retryDelaysMs ?? DEFAULT_RETRY_DELAYS;
+  }
+
+  get backendSessionId(): string | null {
+    return this._sessionId;
+  }
+
+  private startQuery(): void {
+    this.stream = new MessageStream();
+    const options: Record<string, unknown> = {
+      systemPrompt: this.ctx.systemPrompt,
+      cwd: this.ctx.cwd,
+      permissionMode: "bypassPermissions",
+      skills: getSdkSkillsSetting(),
+      hooks: getSdkHooks(),
+    };
+    // Interactive (chat) sessions stream partials and load project/user settings;
+    // headless one-shot jobs keep the leaner option set they had pre-refactor.
+    if (this.ctx.interactive) {
+      options.includePartialMessages = true;
+      options.settingSources = ["project", "user"];
+    }
+    const model = resolveSdkModel(this.ctx.model);
+    if (model) options.model = model;
+    if (this._sessionId) {
+      options.resume = this._sessionId;
+    } else {
+      options.sessionId = randomUUID();
+      // Interactive sessions also forbid auto-continue of a prior session in the
+      // same cwd; jobs always run with a unique id and never auto-continued.
+      if (this.ctx.interactive) options.continue = false;
+    }
+    if (this.ctx.mcpServers) options.mcpServers = this.ctx.mcpServers;
+    if (this.ctx.subagents && Object.keys(this.ctx.subagents).length > 0) options.agents = this.ctx.subagents;
+
+    this.handle = this.queryFn({ prompt: this.stream, options });
+    this.iterator = this.handle[Symbol.asyncIterator]();
+  }
+
+  async *send(text: string, attachments?: Attachment[]): AsyncIterable<AgentEvent> {
+    let sawSession = false;
+    while (true) {
+      if (!this.iterator || !this.stream) this.startQuery();
+      this.stream!.push(text, attachments);
+      const normalizer = new SdkNormalizer();
+      let retry = false;
+
+      while (true) {
+        let res: IteratorResult<unknown>;
+        try {
+          res = await this.iterator!.next();
+        } catch (err) {
+          if (this.aborted) throw new Error(this.aborted);
+          throw err instanceof Error ? err : new Error(String(err));
+        }
+        if (this.aborted) throw new Error(this.aborted);
+        if (res.done) {
+          if (this.aborted) throw new Error(this.aborted);
+          throw new Error("stream ended without result");
+        }
+
+        for (const ev of normalizer.consume(res.value)) {
+          if (ev.type === "session") {
+            this._sessionId = ev.backendSessionId;
+            if (!sawSession) {
+              sawSession = true;
+              yield ev;
+            }
+            continue;
+          }
+          if (ev.type === "error" && ev.retryable && this.retryCount < MAX_SEND_RETRIES) {
+            this.retryCount++;
+            yield { type: "thinking", delta: "retrying after API error..." };
+            await this.teardown();
+            await sleep(this.retryDelays[this.retryCount - 1] ?? 8_000);
+            retry = true;
+            break;
+          }
+          yield ev;
+          if (ev.type === "result" || ev.type === "error") {
+            this.retryCount = 0;
+            return;
+          }
+        }
+        if (retry) break; // restart the outer loop: startQuery() resumes the same session id
+      }
+    }
+  }
+
+  abort(reason: string): void {
+    this.aborted = reason;
+    this.handle?.close();
+  }
+
+  private async teardown(): Promise<void> {
+    this.stream?.end();
+    this.handle?.close();
+    this.stream = null;
+    this.handle = null;
+    this.iterator = null;
+  }
+
+  async close(): Promise<void> {
+    await this.teardown();
+  }
+}

package/src/agent/backends/codex-normalize.ts

@@ -0,0 +1,76 @@
+import type { AgentEvent, Normalizer } from "../types";
+import { truncate } from "../../utils/format-activity";
+
+/**
+ * Pure reducer: Codex `codex exec --json` JSONL events → normalized `AgentEvent`s.
+ *
+ * Codex is batch (no token streaming): the assistant message arrives whole in a
+ * single `item.completed`/`agent_message`, and `turn.completed` carries token
+ * usage. So `text` is emitted once (full), then `result` on `turn.completed`.
+ * No I/O — the session that drives it owns process lifecycle. Real errors are
+ * detected from the process exit code by the session, not here (Codex `error`
+ * items are often non-fatal warnings).
+ */
+export class CodexNormalizer implements Normalizer {
+  private threadId = "";
+  private agentText = "";
+
+  get backendSessionId(): string {
+    return this.threadId;
+  }
+
+  consume(message: unknown): AgentEvent[] {
+    const e = message as any;
+    switch (e.type) {
+      case "thread.started":
+        this.threadId = e.thread_id ?? "";
+        return this.threadId ? [{ type: "session", backendSessionId: this.threadId }] : [];
+      case "item.started":
+      case "item.completed":
+        return this.consumeItem(e.type === "item.completed", e.item);
+      case "turn.completed":
+        return [
+          {
+            type: "result",
+            text: this.agentText,
+            usage: {
+              tokens: {
+                input: e.usage?.input_tokens ?? 0,
+                output: e.usage?.output_tokens ?? 0,
+              },
+            },
+            backendSessionId: this.threadId,
+          },
+        ];
+      default:
+        return [];
+    }
+  }
+
+  private consumeItem(completed: boolean, item: any): AgentEvent[] {
+    if (!item) return [];
+    switch (item.type) {
+      case "command_execution":
+        // Surface the command as activity once, when it starts.
+        if (!completed && item.command)
+          return [{ type: "tool", name: "command", summary: truncate(String(item.command), 70) }];
+        return [];
+      case "mcp_tool_call": {
+        if (completed) return [];
+        const name = item.server ? `${item.server}.${item.tool ?? "tool"}` : item.tool || "mcp";
+        return [{ type: "tool", name, summary: item.tool }];
+      }
+      case "reasoning":
+        if (completed && item.text) return [{ type: "thinking", delta: truncate(String(item.text), 70) }];
+        return [];
+      case "agent_message":
+        if (completed && typeof item.text === "string") {
+          this.agentText = item.text;
+          return [{ type: "text", delta: item.text }];
+        }
+        return [];
+      default:
+        return [];
+    }
+  }
+}

package/src/agent/backends/codex.ts

@@ -0,0 +1,208 @@
+import { existsSync, readdirSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import type { AgentBackend, AgentSession, AgentSessionContext, AgentEvent } from "../types";
+import type { Attachment } from "../../types/attachment";
+import type { McpSourceContext } from "../../mcp";
+import { CodexNormalizer } from "./codex-normalize";
+import { mintRun, revokeRun } from "../mcp-endpoint";
+
+/**
+ * Resolve the codex binary's absolute path. The daemon runs under launchd with a
+ * minimal PATH (`/usr/bin:/bin:...`) that excludes nvm/homebrew bins, so a bare
+ * `codex` spawn would fail. Search the likely install locations (env override,
+ * the runtime's own bin, homebrew, every nvm node bin, bun) and fall back to
+ * PATH only as a last resort. Cached after first resolution.
+ */
+let cachedCodexBin: string | null = null;
+export function resolveCodexBin(): string {
+  if (cachedCodexBin) return cachedCodexBin;
+  const candidates: string[] = [];
+  if (process.env.CODEX_PATH) candidates.push(process.env.CODEX_PATH);
+  candidates.push(join(dirname(process.execPath), "codex")); // sibling of bun/node
+  candidates.push("/opt/homebrew/bin/codex", "/usr/local/bin/codex");
+  try {
+    const nvm = join(homedir(), ".nvm", "versions", "node");
+    for (const v of readdirSync(nvm)) candidates.push(join(nvm, v, "bin", "codex"));
+  } catch {
+    /* no nvm */
+  }
+  candidates.push(join(homedir(), ".bun", "bin", "codex"));
+  cachedCodexBin = candidates.find((p) => existsSync(p)) ?? "codex";
+  return cachedCodexBin;
+}
+
+/** Minimal spawned-process surface, injectable so the session is unit-testable. */
+export interface CliProc {
+  stdout: ReadableStream<Uint8Array>;
+  stderr: ReadableStream<Uint8Array>;
+  exited: Promise<number>;
+  kill(): void;
+}
+export type SpawnFn = (args: string[], opts: { cwd: string; env: Record<string, string> }) => CliProc;
+
+// Nia secrets that must never reach a third-party agent subprocess. Codex
+// authenticates via its own ~/.codex login, not these.
+const SCRUB = new Set([
+  "ANTHROPIC_API_KEY",
+  "SLACK_BOT_TOKEN",
+  "SLACK_APP_TOKEN",
+  "TELEGRAM_BOT_TOKEN",
+  "TWILIO_AUTH_TOKEN",
+  "DATABASE_URL",
+]);
+
+function scrubbedEnv(extra: Record<string, string>): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (!SCRUB.has(k) && v != null) env[k] = v;
+  }
+  return { ...env, ...extra };
+}
+
+function defaultSpawn(args: string[], opts: { cwd: string; env: Record<string, string> }): CliProc {
+  const proc = Bun.spawn([resolveCodexBin(), ...args], {
+    cwd: opts.cwd,
+    env: opts.env,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return {
+    stdout: proc.stdout as ReadableStream<Uint8Array>,
+    stderr: proc.stderr as ReadableStream<Uint8Array>,
+    exited: proc.exited,
+    kill: () => proc.kill(),
+  };
+}
+
+async function* readLines(stream: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let idx: number;
+    while ((idx = buf.indexOf("\n")) >= 0) {
+      yield buf.slice(0, idx);
+      buf = buf.slice(idx + 1);
+    }
+  }
+  if (buf.trim()) yield buf;
+}
+
+async function readAll(stream: ReadableStream<Uint8Array>): Promise<string> {
+  let out = "";
+  const decoder = new TextDecoder();
+  const reader = stream.getReader();
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    out += decoder.decode(value, { stream: true });
+  }
+  return out;
+}
+
+export class CodexBackend implements AgentBackend {
+  readonly name = "codex" as const;
+  private spawnFn: SpawnFn;
+
+  constructor(deps?: { spawnFn?: SpawnFn }) {
+    this.spawnFn = deps?.spawnFn ?? defaultSpawn;
+  }
+
+  async openSession(ctx: AgentSessionContext): Promise<AgentSession> {
+    return new CodexSession(ctx, this.spawnFn);
+  }
+
+  async canResume(): Promise<boolean> {
+    // v1: no thread resume; failover/continuity replays history from Nia's DB.
+    return false;
+  }
+}
+
+class CodexSession implements AgentSession {
+  private _sessionId: string | null = null;
+  private aborted: string | null = null;
+  private proc: CliProc | null = null;
+
+  constructor(
+    private ctx: AgentSessionContext,
+    private spawnFn: SpawnFn,
+  ) {}
+
+  get backendSessionId(): string | null {
+    return this._sessionId;
+  }
+
+  async *send(text: string, _attachments?: Attachment[]): AsyncIterable<AgentEvent> {
+    const source: McpSourceContext = this.ctx.source ?? { channel: this.ctx.channel, room: this.ctx.room };
+    const { url, token } = await mintRun(source);
+
+    const fullPrompt = `${this.ctx.systemPrompt}\n\n---\n\n${text}`;
+    const args = [
+      "exec",
+      fullPrompt,
+      "--json",
+      "--skip-git-repo-check",
+      "--dangerously-bypass-approvals-and-sandbox",
+      "-C",
+      this.ctx.cwd,
+      "-c",
+      `mcp_servers.nia.url="${url}"`,
+      "-c",
+      `mcp_servers.nia.bearer_token_env_var="NIA_MCP_TOKEN"`,
+    ];
+    if (this.ctx.model && this.ctx.model !== "default") args.push("-m", this.ctx.model);
+
+    const proc = this.spawnFn(args, { cwd: this.ctx.cwd, env: scrubbedEnv({ NIA_MCP_TOKEN: token }) });
+    this.proc = proc;
+
+    const normalizer = new CodexNormalizer();
+    let sawResult = false;
+    try {
+      for await (const line of readLines(proc.stdout)) {
+        if (this.aborted) throw new Error(this.aborted);
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        for (const ev of normalizer.consume(parsed)) {
+          if (ev.type === "session" || ev.type === "result") {
+            this._sessionId = ev.backendSessionId || this._sessionId;
+          }
+          if (ev.type === "result") sawResult = true;
+          yield ev;
+        }
+      }
+      const exit = await proc.exited;
+      if (this.aborted) throw new Error(this.aborted);
+      if (exit !== 0 && !sawResult) {
+        const stderr = await readAll(proc.stderr);
+        yield {
+          type: "error",
+          message: stderr.trim() || `codex exited ${exit}`,
+          retryable: false,
+          providerDown: false,
+        };
+      }
+    } finally {
+      revokeRun(token);
+      this.proc = null;
+    }
+  }
+
+  abort(reason: string): void {
+    this.aborted = reason;
+    this.proc?.kill();
+  }
+
+  async close(): Promise<void> {
+    // codex exec is one-shot per send; nothing persistent to tear down.
+  }
+}

package/src/agent/index.ts

@@ -0,0 +1,12 @@
+export type {
+  AgentBackend,
+  AgentSession,
+  AgentSessionContext,
+  AgentEvent,
+  AgentUsage,
+  AgentDef,
+  Normalizer,
+} from "./types";
+export { isResultEvent } from "./types";
+export { getBackend, setBackend, setBackendChain, resolveBackends } from "./registry";
+export { resolveSdkModel } from "./backends/claude";