niahere 0.5.6 → 0.5.8

package/package.json

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

package/src/agent/auth.ts

@@ -2,6 +2,8 @@ import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import type { ProviderName } from "./models";
+import { resolveClaudeCredential } from "./credentials";
+import { getConfig } from "../utils/config";
 
 /**
  * Provider sign-in state, read from whatever each CLI stores on disk.
@@ -43,6 +45,17 @@ const defaultReader: AuthReader = {
   env: (k) => process.env[k],
 };
 
+/** Config is optional here: a health check must never fail because config is
+ *  unreadable, it must say so. */
+function credentialConfig(): { anthropic_oauth_token: string | null; anthropic_api_key: string | null } {
+  try {
+    const c = getConfig();
+    return { anthropic_oauth_token: c.anthropic_oauth_token, anthropic_api_key: c.anthropic_api_key };
+  } catch {
+    return { anthropic_oauth_token: null, anthropic_api_key: null };
+  }
+}
+
 export function claudeCredentialsPath(): string {
   return join(homedir(), ".claude", ".credentials.json");
 }
@@ -62,8 +75,16 @@ function ago(ms: number): string {
 export function claudeAuthStatus(now: number = Date.now(), reader: AuthReader = defaultReader): AuthStatus {
   const base = { provider: "claude" as const };
 
-  if (reader.env("ANTHROPIC_API_KEY")) {
-    return { ...base, state: "ok", detail: "API key (no expiry)" };
+  // Ask the same resolver the backend uses. Reading the environment here while
+  // the backend also reads config meant the check could report one credential
+  // while a different one served the turn — the exact ambiguity this exists to
+  // remove.
+  const credential = resolveClaudeCredential(credentialConfig(), reader.env);
+  if (credential.kind === "oauth_token") {
+    return { ...base, state: "ok", detail: "configured oauth token (subscription, no refresh needed)" };
+  }
+  if (credential.kind === "api_key") {
+    return { ...base, state: "ok", detail: "configured API key (metered — billed per token)" };
   }
 
   const path = claudeCredentialsPath();
@@ -97,7 +118,11 @@ export function claudeAuthStatus(now: number = Date.now(), reader: AuthReader =
     return { ...status, state: "stale", detail: `access token lapsed ${ago(now - access)} ago, renewable${plan}` };
   }
   if (access !== undefined) {
-    return { ...status, state: "ok", detail: `valid for ${ago(access - now)}${plan}` };
+    return {
+      ...status,
+      state: "ok",
+      detail: `Claude Code login, valid for ${ago(access - now)}${plan} — renewed only when the CLI is used here`,
+    };
   }
   return { ...status, state: "unknown", detail: "credentials file carries no expiry" };
 }

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

@@ -90,6 +90,16 @@ function attribute(modelUsage: unknown): Record<string, unknown> | undefined {
  * stay backend-agnostic.
  */
 export class SdkNormalizer implements Normalizer {
+  /**
+   * The SDK's `apiKeySource` only describes where an *API key* came from: it
+   * reports "none" for every OAuth path, so it cannot tell a configured token
+   * from the CLI's inherited login. Nia resolved the credential itself, so it
+   * records that too — the SDK's value is kept because it is genuinely
+   * informative when an API key is in play.
+   */
+  constructor(private readonly credential?: string) {}
+
+  private apiKeySource: string | undefined;
   private accumulatedThinking = "";
   private lastThinkingLine = "";
 
@@ -97,6 +107,10 @@ export class SdkNormalizer implements Normalizer {
     const msg = message as any;
 
     if (msg.type === "system" && msg.subtype === "init") {
+      // apiKeySource names which credential served the session ('oauth' is
+      // Claude Code's own login). Recording it is what makes a silent switch
+      // of credential visible after the fact.
+      if (typeof msg.apiKeySource === "string") this.apiKeySource = msg.apiKeySource;
       return [{ type: "session", backendSessionId: msg.session_id }];
     }
 
@@ -211,6 +225,8 @@ export class SdkNormalizer implements Normalizer {
           terminal_reason: msg.terminal_reason,
           session_id: msg.session_id,
           subtype: msg.subtype,
+          api_key_source: this.apiKeySource,
+          credential: this.credential,
           usage: msg.usage,
           model_usage: attribute(msg.modelUsage),
         },

package/src/agent/backends/claude.ts

@@ -11,6 +11,7 @@ import { MessageStream } from "../message-stream";
 import { getSdkSkillsSetting } from "../../core/skills";
 import { getSdkHooks } from "../../core/sdk-hooks";
 import { getConfig } from "../../utils/config";
+import { resolveClaudeCredential, credentialEnv } from "../credentials";
 import { sleep } from "../../utils/retry";
 
 /** The shape of the SDK `query()` handle the session consumes. Injected so the
@@ -106,6 +107,14 @@ class ClaudeSession implements AgentSession {
       // same cwd; jobs always run with a unique id and never auto-continued.
       if (this.ctx.interactive) options.continue = false;
     }
+    // Hand the CLI a credential Nia owns when one is configured. Without this
+    // it inherits ~/.claude/.credentials.json, which only refreshes when a
+    // human runs `claude` on this machine — the coupling that had Nia
+    // answering as codex for sixteen days.
+    const credential = resolveClaudeCredential(getConfig());
+    if (credential.envVar) {
+      options.env = credentialEnv(credential, process.env as Record<string, string>);
+    }
     if (this.ctx.outputSchema) options.outputFormat = { type: "json_schema", schema: this.ctx.outputSchema };
     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;
@@ -119,7 +128,7 @@ class ClaudeSession implements AgentSession {
     while (true) {
       if (!this.iterator || !this.stream) this.startQuery();
       this.stream!.push(text, attachments);
-      const normalizer = new SdkNormalizer();
+      const normalizer = new SdkNormalizer(resolveClaudeCredential(getConfig()).kind);
       let retry = false;
 
       while (true) {

package/src/agent/credentials.ts

@@ -0,0 +1,77 @@
+import type { Config } from "../types/config";
+
+/**
+ * Which Claude credential the daemon should use, and where it came from.
+ *
+ * Nia used to have no answer to this: it inherited whatever `claude` had last
+ * written to `~/.claude/.credentials.json`, refreshed by a human opening a
+ * terminal on the same machine. When that stopped, Nia answered as codex for
+ * sixteen days and nothing said why. A credential the daemon is handed
+ * explicitly is one it can report on, and one that does not lapse because
+ * nobody logged in today.
+ */
+
+export type CredentialKind = "oauth_token" | "api_key" | "claude_code_login";
+
+export interface ClaudeCredential {
+  kind: CredentialKind;
+  /** The variable the CLI reads it from. Absent for the inherited login. */
+  envVar?: "CLAUDE_CODE_OAUTH_TOKEN" | "ANTHROPIC_API_KEY";
+  value?: string;
+  /**
+   * `subscription` rides the plan. `metered` bills per token — worth saying out
+   * loud, because Nia has run $552 in a week and that is an invoice on the API.
+   */
+  billing: "subscription" | "metered";
+}
+
+/** Every variable a credential could occupy, so switching never leaves a stale one behind. */
+const TOKEN_VARS = ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY"] as const;
+
+const clean = (v: unknown): string | undefined => {
+  const s = typeof v === "string" ? v.trim() : "";
+  return s.length > 0 ? s : undefined;
+};
+
+export type EnvLookup = (key: string) => string | undefined;
+
+/**
+ * Config first, then the ambient environment, then Claude Code's own login.
+ * Config wins so the daemon is not at the mercy of whatever shell launched it.
+ */
+export function resolveClaudeCredential(
+  config: Pick<Config, "anthropic_oauth_token" | "anthropic_api_key">,
+  env: EnvLookup = (k) => process.env[k],
+): ClaudeCredential {
+  const oauth = clean(config.anthropic_oauth_token) ?? clean(env("CLAUDE_CODE_OAUTH_TOKEN"));
+  if (oauth) {
+    return { kind: "oauth_token", envVar: "CLAUDE_CODE_OAUTH_TOKEN", value: oauth, billing: "subscription" };
+  }
+  const key = clean(config.anthropic_api_key) ?? clean(env("ANTHROPIC_API_KEY"));
+  if (key) {
+    return { kind: "api_key", envVar: "ANTHROPIC_API_KEY", value: key, billing: "metered" };
+  }
+  return { kind: "claude_code_login", billing: "subscription" };
+}
+
+/**
+ * The environment for the spawned CLI. The base is passed through — it still
+ * needs PATH and HOME — with exactly one credential variable set, and any other
+ * cleared so a removed credential stops working immediately rather than at the
+ * next restart.
+ */
+export function credentialEnv(credential: ClaudeCredential, base: Record<string, string>): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const [k, v] of Object.entries(base)) {
+    if ((TOKEN_VARS as readonly string[]).includes(k)) continue;
+    env[k] = v;
+  }
+  if (credential.envVar && credential.value) env[credential.envVar] = credential.value;
+  return env;
+}
+
+export function describeCredential(credential: ClaudeCredential): string {
+  if (credential.kind === "oauth_token") return "configured oauth token (subscription, long-lived)";
+  if (credential.kind === "api_key") return "configured API key (metered, billed per token)";
+  return "Claude Code's own login (refreshed by whoever last used the CLI here)";
+}

package/src/channels/common/reply.ts

@@ -0,0 +1,79 @@
+/**
+ * What counts as a reply, and what is just the model talking to itself.
+ *
+ * Two related jobs live here on purpose, because splitting them is how the
+ * codebase ended up with two sentinel parsers that disagreed:
+ *
+ *  - `shouldSuppressReply` is the cross-channel guard. Control artifacts have
+ *    escaped as real messages before — `nia send --help` once DM'd the flag
+ *    itself — so every channel checks the same list.
+ *  - `decideWatchReply` is the richer judgement a watch turn needs: it prefers
+ *    a schema's answer, and can tell a bare sentinel from one tangled up with
+ *    content.
+ */
+
+export const WATCH_JUDGEMENT_SCHEMA: Record<string, unknown> = {
+  type: "object",
+  properties: {
+    reply: {
+      type: ["string", "null"],
+      description: "The message to post in the channel, or null to stay silent. Most turns are null.",
+    },
+  },
+  required: ["reply"],
+  additionalProperties: false,
+};
+
+/** Strip markdown fencing so a sentinel matches even when the model wraps it.
+ *  Underscores are left alone — the sentinel contains one. */
+export function cleanControlReply(text: string): string {
+  return text.replace(/[`*]/g, "").trim();
+}
+
+/** Outputs that are control artifacts rather than anything a person should see. */
+const CONTROL_ARTIFACTS = new Set(["[NO_REPLY]", "--help", "-h"]);
+
+/**
+ * Exact matches only. "Use `--help` to see the flags" is a real answer and must
+ * survive; a reply that is nothing but `--help` is the CLI leaking.
+ */
+export function shouldSuppressReply(text: string): boolean {
+  const cleaned = cleanControlReply(text);
+  return !cleaned || CONTROL_ARTIFACTS.has(cleaned);
+}
+
+export interface WatchDecision {
+  /** Whether to post at all. */
+  send: boolean;
+  /** What to post. Empty when staying quiet. */
+  text: string;
+  /** Which path decided, so a drop in schema coverage is visible in the log. */
+  source: "structured" | "sentinel";
+  /** Set only on the sentinel path, when the model emitted both a sentinel and content. */
+  ambiguous?: boolean;
+}
+
+/**
+ * `structured` wins when it carries the `reply` key the schema requires —
+ * including an explicit null, which is a decision, not an absence.
+ *
+ * The sentinel fallback matches `[NO_REPLY]` anywhere, not just exactly: a watch
+ * turn that says both is confused, and staying quiet is the safer reading. That
+ * is deliberately looser than `shouldSuppressReply`, which guards ordinary
+ * replies where a substring match would swallow real answers.
+ */
+export function decideWatchReply(structured: unknown, raw: string): WatchDecision {
+  if (structured && typeof structured === "object" && "reply" in structured) {
+    const reply = (structured as { reply: unknown }).reply;
+    const text = typeof reply === "string" ? reply.trim() : "";
+    return { send: text.length > 0, text, source: "structured" };
+  }
+
+  const trimmed = raw.trim();
+  const cleaned = cleanControlReply(trimmed);
+  if (!trimmed || cleaned.includes("[NO_REPLY]") || CONTROL_ARTIFACTS.has(cleaned)) {
+    const exact = !trimmed || CONTROL_ARTIFACTS.has(cleaned);
+    return { send: false, text: "", source: "sentinel", ambiguous: !exact };
+  }
+  return { send: true, text: trimmed, source: "sentinel" };
+}

package/src/channels/slack.ts

@@ -12,7 +12,7 @@ import { ChatSessions, chainLock } from "./common/chat-session";
 import { SlackAttachmentCache } from "./slack/attachments";
 import { SlackWatchReloader } from "./slack/watch";
 
-import { decideWatchReply } from "./common/watch-judgement";
+import { decideWatchReply, shouldSuppressReply } from "./common/reply";
 import { createTurnPump } from "./common/coalesce";
 
 const logActivity = (status: string) => log.debug({ status }, "slack engine activity");
@@ -304,7 +304,8 @@ class SlackChannel implements Channel {
             const { result } = await state.engine.send(subcommand, {
               onActivity: logActivity,
             });
-            await respond(result.trim() || "(no response)");
+            if (shouldSuppressReply(result)) return;
+            await respond(result.trim());
           } catch (err) {
             const errText = errMsg(err);
             await respond(`[error] ${errText}`);

package/src/channels/sms.ts

@@ -23,6 +23,8 @@ import { errMsg, ignore } from "../utils/errors";
 import { sendMessage as twilioSendMessage } from "./twilio/rest";
 import { getTwilioServer } from "./twilio/server";
 import { ChatSessions, chainLock } from "./common/chat-session";
+import { Message } from "../db/models";
+import { shouldSuppressReply } from "./common/reply";
 import { ackTwiml, deliveryStatusAck, isAllowedSender } from "./twilio/shared";
 
 class SmsChannel implements Channel {
@@ -105,8 +107,13 @@ class SmsChannel implements Channel {
     // Twilio's ~15s webhook timeout when the engine takes longer.
     chainLock(state, async () => {
       try {
-        const { result } = await state.engine.send(body);
-        const reply = result.trim() || "(no response)";
+        const { result, messageId } = await state.engine.send(body);
+        const reply = result.trim();
+        if (shouldSuppressReply(reply)) {
+          if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record suppressed delivery status");
+          log.info({ from }, "sms: agent chose not to reply");
+          return;
+        }
         await this.sendTo(from, reply);
       } catch (err) {
         log.error({ err, from }, "sms: engine error");

package/src/channels/telegram.ts

@@ -12,6 +12,7 @@ import { getMcpServers } from "../mcp";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
 import { getNiaHome } from "../utils/paths";
 import { ChatSessions, chainLock } from "./common/chat-session";
+import { shouldSuppressReply } from "./common/reply";
 
 function safeExtension(filename?: string): string {
   const ext = filename?.split(".").pop();
@@ -187,7 +188,12 @@ class TelegramChannel implements Channel {
 
     try {
       const { result, messageId } = await state.engine.send(text, {}, attachments);
-      const reply = result.trim() || "(no response)";
+      const reply = result.trim();
+        if (shouldSuppressReply(reply)) {
+          if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record suppressed delivery status");
+          log.info({ chatId }, "telegram: agent chose not to reply");
+          return;
+        }
       try {
         await bot.api.sendMessage(chatId, reply);
         if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");

package/src/channels/whatsapp.ts

@@ -21,6 +21,7 @@ import { getMcpServers } from "../mcp";
 import { Message } from "../db/models";
 import { runMigrations } from "../db/migrate";
 import { ChatSessions, chainLock } from "./common/chat-session";
+import { shouldSuppressReply } from "./common/reply";
 import { ackTwiml, deliveryStatusAck, isAllowedSender } from "./twilio/shared";
 import type { Attachment, Channel, ChatState, Outbound, TwilioConfig, WhatsappConfig, PhoneConfig } from "../types";
 import { getConfig } from "../utils/config";
@@ -201,7 +202,12 @@ class WhatsAppChannel implements Channel {
 
       try {
         const { result, messageId } = await state.engine.send(userText || "(media only)", {}, attachments);
-        const reply = result.trim() || "(no response)";
+        const reply = result.trim();
+        if (shouldSuppressReply(reply)) {
+          if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record suppressed delivery status");
+          log.info({ from }, "whatsapp: agent chose not to reply");
+          return;
+        }
         try {
           await this.sendTextTo(from, reply);
           if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");

package/src/cli/channels.ts

@@ -1,28 +1,38 @@
 import { getConfig, updateRawConfig } from "../utils/config";
 import { getPaths } from "../utils/paths";
 import { errMsg } from "../utils/errors";
-import { fail, ICON_PASS, ICON_FAIL } from "../utils/cli";
+import { fail, ICON_PASS, ICON_FAIL, parseArgs } from "../utils/cli";
 import { log } from "../utils/log";
 
+const SEND_USAGE = "Usage: nia send [-c channel] [--to <slack-channel-id>] [--thread <ts>] <message>";
+
+export interface SendArgs {
+  channel?: string;
+  toChannelId?: string;
+  threadTs?: string;
+  message: string;
+  help: boolean;
+}
+
+/** Extracted so the parse is testable — `nia send --help` used to DM the flag. */
+export function parseSendArgs(args: string[] = process.argv.slice(3)): SendArgs {
+  const parsed = parseArgs(args);
+  return {
+    channel: parsed.getString("channel") || parsed.getString("c"),
+    toChannelId: parsed.getString("to"),
+    threadTs: parsed.getString("thread"),
+    message: parsed.positional.join(" "),
+    help: parsed.help,
+  };
+}
+
 export async function sendCommand(): Promise<void> {
-  const args = process.argv.slice(3);
-  let channel: string | undefined;
-  let toChannelId: string | undefined;
-  let threadTs: string | undefined;
-  const msgParts: string[] = [];
-  for (let i = 0; i < args.length; i++) {
-    if ((args[i] === "--channel" || args[i] === "-c") && args[i + 1]) {
-      channel = args[++i];
-    } else if (args[i] === "--to" && args[i + 1]) {
-      toChannelId = args[++i];
-    } else if (args[i] === "--thread" && args[i + 1]) {
-      threadTs = args[++i];
-    } else {
-      msgParts.push(args[i]);
-    }
+  let { channel, toChannelId, threadTs, message, help } = parseSendArgs();
+  if (help) {
+    console.log(SEND_USAGE);
+    return;
   }
-  const message = msgParts.join(" ");
-  if (!message) fail("Usage: nia send [-c channel] [--to <slack-channel-id>] [--thread <ts>] <message>");
+  if (!message) fail(SEND_USAGE);
 
   // --to implies slack channel
   if (toChannelId) channel = channel || "slack";

package/src/types/config.ts

@@ -112,6 +112,11 @@ export interface Config {
   activeHours: { start: string; end: string };
   database_url: string;
   log_level: string;
+  /** Long-lived token from `claude setup-token`. Preferred: it keeps the
+   *  subscription and does not depend on anyone logging in on this machine. */
+  anthropic_oauth_token: string | null;
+  /** Metered per-token billing — a different bill from the subscription. */
+  anthropic_api_key: string | null;
   gemini_api_key: string | null;
   sessionFinalization: SessionFinalizationConfig;
   channels: ChannelsConfig;

package/src/utils/config.ts

@@ -15,6 +15,8 @@ const DEFAULTS: Config = {
   activeHours: { start: "00:00", end: "23:59" },
   database_url: DEFAULT_DATABASE_URL,
   log_level: "info",
+  anthropic_oauth_token: null,
+  anthropic_api_key: null,
   gemini_api_key: null,
   sessionFinalization: {
     enabled: true,
@@ -129,6 +131,11 @@ export function loadConfig(): Config {
   const log_level = process.env.LOG_LEVEL || (typeof raw.log_level === "string" ? raw.log_level : DEFAULTS.log_level);
 
   // Gemini API key — env var overrides config
+  const anthropic_oauth_token =
+    process.env.CLAUDE_CODE_OAUTH_TOKEN ||
+    (typeof raw.anthropic_oauth_token === "string" ? raw.anthropic_oauth_token : null);
+  const anthropic_api_key =
+    process.env.ANTHROPIC_API_KEY || (typeof raw.anthropic_api_key === "string" ? raw.anthropic_api_key : null);
   const gemini_api_key =
     process.env.GEMINI_API_KEY || (typeof raw.gemini_api_key === "string" ? raw.gemini_api_key : null);
 
@@ -256,6 +263,8 @@ export function loadConfig(): Config {
     activeHours: { start, end },
     database_url,
     log_level,
+    anthropic_oauth_token,
+    anthropic_api_key,
     gemini_api_key,
     sessionFinalization,
     channels: {

package/src/channels/common/watch-judgement.ts

@@ -1,61 +0,0 @@
-/**
- * A watch turn answers one question: say something, or stay quiet.
- *
- * That answer used to travel as a `[NO_REPLY]` sentinel inside prose, which
- * means parsing a decision out of an answer that was free to phrase it any way
- * it liked. It mostly worked — and 47 times it produced the sentinel *and*
- * content, where the code has to guess which the model meant.
- *
- * A schema removes the guess. The sentinel path stays as the fallback, because
- * a backend can decline to produce structured output and a watch that stops
- * deciding is worse than one that decides the old way.
- */
-
-export const WATCH_JUDGEMENT_SCHEMA: Record<string, unknown> = {
-  type: "object",
-  properties: {
-    reply: {
-      type: ["string", "null"],
-      description: "The message to post in the channel, or null to stay silent. Most turns are null.",
-    },
-  },
-  required: ["reply"],
-  additionalProperties: false,
-};
-
-export interface WatchDecision {
-  /** Whether to post at all. */
-  send: boolean;
-  /** What to post. Empty when staying quiet. */
-  text: string;
-  /** Which path decided, so a drop in schema coverage is visible in the log. */
-  source: "structured" | "sentinel";
-  /** Set only on the sentinel path, when the model emitted both a sentinel and content. */
-  ambiguous?: boolean;
-}
-
-/** Strip markdown fencing so a sentinel matches even when the model wraps it.
- *  Underscores are left alone — the sentinel contains one. */
-export function cleanSentinel(text: string): string {
-  return text.replace(/[`*]/g, "").trim();
-}
-
-/**
- * `structured` wins when it carries the `reply` key the schema requires —
- * including an explicit null, which is a decision, not an absence.
- */
-export function decideWatchReply(structured: unknown, raw: string): WatchDecision {
-  if (structured && typeof structured === "object" && "reply" in structured) {
-    const reply = (structured as { reply: unknown }).reply;
-    const text = typeof reply === "string" ? reply.trim() : "";
-    return { send: text.length > 0, text, source: "structured" };
-  }
-
-  const trimmed = raw.trim();
-  const cleaned = cleanSentinel(trimmed);
-  if (!trimmed || cleaned.includes("[NO_REPLY]")) {
-    const exact = !trimmed || cleaned === "[NO_REPLY]";
-    return { send: false, text: "", source: "sentinel", ambiguous: !exact };
-  }
-  return { send: true, text: trimmed, source: "sentinel" };
-}