tokenmaxxing 0.16.0 → 0.18.0

package/src/lib/sample.ts

@@ -68,13 +68,13 @@ function refreshPlanFields(account: Account, creds: OAuthCreds): void {
 export async function probeParkedUsage(account: Account, opts: { ping?: boolean } = {}): Promise<SampleOutcome> {
   const backup = parkedTarget(account.keychainItem);
   const parkedRaw = await readItem(backup);
-  if (!parkedRaw) return { ok: false, reason: "no parked credential - re-add with `tokenmaxxing add`" };
+  if (!parkedRaw) return { ok: false, reason: "no parked credential - run `tokenmaxxing auth`" };
 
   let creds: OAuthCreds;
   try {
     creds = CredentialBlobSchema.parse(JSON.parse(parkedRaw)).claudeAiOauth;
   } catch (e) {
-    return { ok: false, reason: `parked credential unreadable (${String((e as Error).message ?? e).slice(0, 80)}) - re-add with \`tokenmaxxing add\`` };
+    return { ok: false, reason: `parked credential unreadable (${String((e as Error).message ?? e).slice(0, 80)}) - run \`tokenmaxxing auth\`` };
   }
 
   // Hand claude a token with comfortable headroom so it won't run its own refresh

package/src/lib/settings.ts

@@ -1,7 +1,8 @@
-// Idempotent merge of tokenmaxxing's three entries into the user-owned
-// ~/.claude/settings.json: our statusLine, a Stop hook, a SessionStart hook.
-// Hooks APPEND to existing arrays; the statusLine slot is ours outright -
-// tokenmaxxing renders it natively, so any other statusLine command is replaced.
+// Idempotent merge of tokenmaxxing's entries into the user-owned
+// ~/.claude/settings.json: our statusLine + subagentStatusLine, a Stop hook,
+// a SessionStart hook. Hooks APPEND to existing arrays; the statusLine slots
+// are ours outright - tokenmaxxing renders them natively, so any other
+// statusLine command is replaced.
 
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -19,6 +20,7 @@ const HookGroupSchema = z.looseObject({ matcher: z.string().optional(), hooks: z
 const StatusLineSchema = z.looseObject({ type: z.string(), command: z.string() });
 const SettingsSchema = z.looseObject({
   statusLine: StatusLineSchema.optional(),
+  subagentStatusLine: StatusLineSchema.optional(),
   hooks: z.record(z.string(), z.array(HookGroupSchema)).optional(),
 });
 type Settings = z.infer<typeof SettingsSchema>;
@@ -26,6 +28,7 @@ type HookGroup = z.infer<typeof HookGroupSchema>;
 
 const SUBCMD = {
   statusline: "__statusline",
+  subagentStatusline: "__subagent-statusline",
   stop: "__stop-hook",
   sessionStart: "__session-start",
 } as const;
@@ -44,6 +47,7 @@ export function isOurCommand(cmd: string | undefined): boolean {
   if (!cmd) return false;
   return (
     cmd.includes(SUBCMD.statusline) ||
+    cmd.includes(SUBCMD.subagentStatusline) ||
     cmd.includes(SUBCMD.stop) ||
     cmd.includes(SUBCMD.sessionStart) ||
     // also match the installed bin path even if the subcommand text changes
@@ -70,29 +74,35 @@ function removeHook(s: Settings, event: string, sub: string): void {
   if (s.hooks![event]!.length === 0) delete s.hooks![event];
 }
 
-/** Install the three entries: take the statusLine slot, append our hooks. */
+/** Install the entries: take both statusLine slots, append our hooks. */
 export function installSettings(): void {
   const s = readSettings();
   s.statusLine = {
     type: "command",
     command: `${JSON.stringify(installedBin())} ${SUBCMD.statusline}`,
   };
+  s.subagentStatusLine = {
+    type: "command",
+    command: `${JSON.stringify(installedBin())} ${SUBCMD.subagentStatusline}`,
+  };
   appendHook(s, "Stop", SUBCMD.stop);
   appendHook(s, "SessionStart", SUBCMD.sessionStart);
   writeSettings(s);
 }
 
-/** Remove our three entries. The statusLine slot is deleted only if it is ours. */
+/** Remove our entries. The statusLine slots are deleted only if they are ours. */
 export function uninstallSettings(): void {
   const s = readSettings();
   removeHook(s, "Stop", SUBCMD.stop);
   removeHook(s, "SessionStart", SUBCMD.sessionStart);
   if (s.statusLine && isOurCommand(s.statusLine.command)) delete s.statusLine;
+  if (s.subagentStatusLine && isOurCommand(s.subagentStatusLine.command)) delete s.subagentStatusLine;
   writeSettings(s);
 }
 
 const SettingsCheckSchema = z.object({
   statusLineOk: z.boolean(),
+  subagentStatusLineOk: z.boolean(),
   stopOk: z.boolean(),
   sessionStartOk: z.boolean(),
 });
@@ -104,6 +114,7 @@ export function checkSettings(): SettingsCheck {
     !!s.hooks?.[event]?.some((g) => g.hooks?.some((h) => h.command?.includes(sub)));
   return {
     statusLineOk: isOurCommand(s.statusLine?.command),
+    subagentStatusLineOk: isOurCommand(s.subagentStatusLine?.command),
     stopOk: has("Stop", SUBCMD.stop),
     sessionStartOk: has("SessionStart", SUBCMD.sessionStart),
   };

package/src/lib/slackbridge.ts

@@ -0,0 +1,107 @@
+// The Slack->claude relay. One claude turn per Slack message via the Agent SDK
+// (re-query with resume, never a persistent streaming query: the SDK subprocess
+// reads credentials at spawn, so per-turn spawns are what let the pool decision
+// pick the freshest account at every boundary and let the daemon restart
+// without losing threads). Verified against @anthropic-ai/claude-agent-sdk
+// 0.3.214 and code.claude.com/docs 2026-07-18; both change monthly.
+
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { ensureBestAccount, pooledOptions, stopHookCheck } from "../sdk.ts";
+import { paths } from "./paths.ts";
+import { threadKey, type SlackLink } from "./slackstate.ts";
+import { log } from "./log.ts";
+
+/** Mutated in place by relayTurn so the caller can hand the generator straight
+ *  to thread.post(AsyncIterable) and still read the turn's outcome afterward. */
+export const TurnOutcomeSchema = z.object({
+  sessionId: z.string().nullable(),
+  failed: z.boolean(),
+});
+export type TurnOutcome = z.infer<typeof TurnOutcomeSchema>;
+
+/** Run one git command against a repo; throws with trimmed stderr on failure. */
+function git(repo: string, args: string[]): string {
+  const r = Bun.spawnSync(["git", "-C", repo, ...args], { stdout: "pipe", stderr: "pipe" });
+  const stderr = new TextDecoder().decode(r.stderr).trim();
+  if (r.exitCode !== 0) throw new Error(`git ${args[0]} failed: ${stderr.slice(0, 200)}`);
+  return new TextDecoder().decode(r.stdout).trim();
+}
+
+/**
+ * The stable cwd a thread's turns run in. Worktree mode (default) creates
+ * `slack-worktrees/<threadKey>` on branch `tm-slack-<threadKey>` cut from the
+ * repo's current HEAD, once; both survive daemon restarts because resume is
+ * cwd-keyed. Worktrees are never auto-deleted (they hold the thread's work):
+ * clean up with `git worktree remove` when done.
+ */
+export function ensureThreadCwd(input: { link: SlackLink; threadId: string }): string {
+  if (!input.link.worktree) return input.link.repo;
+  const key = threadKey(input.threadId);
+  const dir = join(paths.slackWorktreesDir, key);
+  if (existsSync(dir)) return dir;
+  mkdirSync(paths.slackWorktreesDir, { recursive: true });
+  const branch = `tm-slack-${key}`;
+  const branchExists = Bun.spawnSync(["git", "-C", input.link.repo, "rev-parse", "--verify", "--quiet", branch]).exitCode === 0;
+  // a crash between branch creation and worktree add leaves the branch behind;
+  // reattach instead of failing on -b collision.
+  if (branchExists) git(input.link.repo, ["worktree", "add", dir, branch]);
+  else git(input.link.repo, ["worktree", "add", dir, "-b", branch]);
+  log("serve.worktree_created", { dir, branch });
+  return dir;
+}
+
+/**
+ * One claude turn, yielded as streaming text deltas (feed directly to
+ * thread.post). Never throws: a failure yields a short diagnostic line and
+ * sets outcome.failed (the daemon must keep serving other threads). Error
+ * text is message-only - a raw error body could echo request material.
+ */
+export async function* relayTurn(
+  input: { cwd: string; sessionId: string | null; prompt: string; link: SlackLink },
+  outcome: TurnOutcome,
+): AsyncGenerator<string> {
+  let yieldedAny = false;
+  try {
+    // the switch decision runs at the spawn boundary, same as the CLI hooks.
+    await ensureBestAccount();
+    const q = query({
+      prompt: input.prompt,
+      options: {
+        ...pooledOptions(),
+        cwd: input.cwd,
+        permissionMode: input.link.permissionMode,
+        includePartialMessages: true,
+        hooks: { Stop: [{ hooks: [stopHookCheck] }] },
+        ...(input.link.model ? { model: input.link.model } : {}),
+        ...(input.sessionId ? { resume: input.sessionId } : {}),
+      },
+    });
+    let result: string | null = null;
+    for await (const message of q) {
+      if (message.type === "system" && message.subtype === "init") outcome.sessionId = message.session_id;
+      if (message.type === "stream_event") {
+        const event = message.event;
+        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          yieldedAny = true;
+          yield event.delta.text;
+        }
+      }
+      if (message.type === "result") {
+        outcome.sessionId = message.session_id;
+        if (message.subtype === "success") result = message.result;
+        else outcome.failed = true;
+      }
+    }
+    // a turn that produced no streamed text (tool-only turns) still reports.
+    if (!yieldedAny && result) yield result;
+    if (!yieldedAny && !result && outcome.failed) yield "the turn ended without a result (limit or error) - trying again may help";
+  } catch (e) {
+    outcome.failed = true;
+    const detail = (e instanceof Error ? e.message : String(e)).slice(0, 300);
+    log("serve.turn_error", { err: detail });
+    yield `${yieldedAny ? "\n\n" : ""}tokenmaxxing: turn failed: ${detail}`;
+  }
+}

package/src/lib/slackstate.ts

@@ -0,0 +1,125 @@
+// `xx serve` state. slack.json holds the Slack tokens plus the channel->repo
+// links; it is credential material (xoxb-/xapp-), so it is written 0600 and its
+// tokens must never be printed. Per-thread records under slack-threads/ pin the
+// claude session id + cwd a Slack thread resumes into (resume is cwd-keyed, so
+// the cwd must stay byte-stable for the thread's whole life). A present but
+// unparseable slack.json THROWS (no silent empty config); absent = null.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { paths } from "./paths.ts";
+import { writeFileAtomic } from "./atomic.ts";
+
+/** Claude Agent SDK permission modes an unattended bridge may run under.
+ *  acceptEdits (default) auto-approves file edits but not arbitrary Bash;
+ *  bypassPermissions is full autonomy - a per-link, user-chosen risk posture. */
+export const ServePermissionModeSchema = z.enum(["default", "acceptEdits", "bypassPermissions", "dontAsk", "plan"]);
+
+export const SlackLinkSchema = z.object({
+  /** Slack channel id (C.../G...). Names are not stored - ids are stable. */
+  channel: z.string(),
+  /** absolute path of the git repo this channel drives. */
+  repo: z.string(),
+  /** run each thread in its own git worktree (user default 2026-07-18: true). */
+  worktree: z.boolean().default(true),
+  permissionMode: ServePermissionModeSchema.default("acceptEdits"),
+  /** optional model override for this repo's sessions. */
+  model: z.string().optional(),
+});
+export type SlackLink = z.infer<typeof SlackLinkSchema>;
+
+export const SlackConfigSchema = z.object({
+  botToken: z.string().startsWith("xoxb-"),
+  appToken: z.string().startsWith("xapp-"),
+  links: z.array(SlackLinkSchema).default([]),
+});
+export type SlackConfig = z.infer<typeof SlackConfigSchema>;
+
+export function loadSlackConfig(): SlackConfig | null {
+  if (!existsSync(paths.slackJson)) return null;
+  return SlackConfigSchema.parse(JSON.parse(readFileSync(paths.slackJson, "utf8")));
+}
+
+export function saveSlackConfig(cfg: SlackConfig): void {
+  writeFileAtomic(paths.slackJson, JSON.stringify(SlackConfigSchema.parse(cfg), null, 2) + "\n", 0o600);
+}
+
+/** A Slack channel id: C (public) or G (private/legacy) followed by uppercase
+ *  alphanumerics. Structural check, no regex. */
+export function isChannelId(s: string): boolean {
+  if (s.length < 2 || (s[0] !== "C" && s[0] !== "G")) return false;
+  const rest = s.slice(1);
+  return [...rest].every((ch) => (ch >= "0" && ch <= "9") || (ch >= "A" && ch <= "Z"));
+}
+
+// ---- per-thread session records -------------------------------------------
+
+export const SlackThreadSchema = z.object({
+  /** chat-sdk thread id, e.g. "slack:C0123:1721300000.123456". */
+  threadId: z.string(),
+  repo: z.string(),
+  /** the dir every turn of this thread runs in (repo or its worktree). */
+  cwd: z.string(),
+  /** claude session id; null until the first turn's init message arrives. */
+  sessionId: z.string().nullable(),
+  createdAt: z.string(),
+});
+export type SlackThread = z.infer<typeof SlackThreadSchema>;
+
+/** Filesystem-safe key for a thread id: alnum kept, everything else "-". */
+export function threadKey(threadId: string): string {
+  return [...threadId]
+    .map((ch) => ((ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z") || (ch >= "0" && ch <= "9") ? ch : "-"))
+    .join("");
+}
+
+function threadFile(threadId: string): string {
+  return join(paths.slackThreadsDir, `${threadKey(threadId)}.json`);
+}
+
+export function loadSlackThread(threadId: string): SlackThread | null {
+  const f = threadFile(threadId);
+  if (!existsSync(f)) return null;
+  return SlackThreadSchema.parse(JSON.parse(readFileSync(f, "utf8")));
+}
+
+export function saveSlackThread(t: SlackThread): void {
+  writeFileAtomic(threadFile(t.threadId), JSON.stringify(SlackThreadSchema.parse(t), null, 2) + "\n");
+}
+
+export function listSlackThreads(): SlackThread[] {
+  if (!existsSync(paths.slackThreadsDir)) return [];
+  const out: SlackThread[] = [];
+  for (const f of readdirSync(paths.slackThreadsDir)) {
+    if (!f.endsWith(".json")) continue;
+    out.push(SlackThreadSchema.parse(JSON.parse(readFileSync(join(paths.slackThreadsDir, f), "utf8"))));
+  }
+  return out;
+}
+
+// ---- pure link edits (unit-tested) ----------------------------------------
+
+export function upsertLink(cfg: SlackConfig, link: SlackLink): SlackConfig {
+  const links = cfg.links.filter((l) => l.channel !== link.channel);
+  links.push(link);
+  return { ...cfg, links };
+}
+
+export function removeLink(cfg: SlackConfig, channel: string): SlackConfig | null {
+  if (!cfg.links.some((l) => l.channel === channel)) return null;
+  return { ...cfg, links: cfg.links.filter((l) => l.channel !== channel) };
+}
+
+export function linkForChannel(cfg: SlackConfig, channel: string): SlackLink | null {
+  return cfg.links.find((l) => l.channel === channel) ?? null;
+}
+
+/** Strip a leading Slack mention token ("<@U0123> rest") from message text. */
+export function stripLeadingMention(text: string): string {
+  const trimmed = text.trimStart();
+  if (!trimmed.startsWith("<@")) return text.trim();
+  const close = trimmed.indexOf(">");
+  if (close < 0) return text.trim();
+  return trimmed.slice(close + 1).trim();
+}

package/src/lib/types.ts

@@ -196,6 +196,28 @@ export const StatusLineStdinSchema = RateLimitsStdinSchema.extend({
   effort: z.looseObject({ level: z.string().optional() }).nullable().optional().catch(undefined),
 });
 
+/** subagentStatusLine stdin: base session fields plus one entry per active
+ *  subagent task (verified against the 2.1.214 bundle + docs 2026-07-18;
+ *  tasks[].model/contextWindowSize need claude >= 2.1.205, effort >= 2.1.214).
+ *  Same loose + catch degradation contract as StatusLineStdinSchema. */
+export const SubagentStatusLineStdinSchema = z.looseObject({
+  tasks: z
+    .array(
+      z.looseObject({
+        id: z.string().optional(),
+        name: z.string().nullable().optional().catch(undefined),
+        description: z.string().nullable().optional().catch(undefined),
+        label: z.string().nullable().optional().catch(undefined),
+        model: z.string().nullable().optional().catch(undefined),
+        effort: z.string().nullable().optional().catch(undefined),
+        contextWindowSize: z.number().nullable().optional().catch(undefined),
+        tokenCount: z.number().nullable().optional().catch(undefined),
+      }),
+    )
+    .optional()
+    .catch(undefined),
+});
+
 /** Success body of the OAuth refresh grant. */
 export const RefreshResponseSchema = z.looseObject({
   access_token: z.string(),

package/src/main.ts

@@ -6,10 +6,12 @@
 import { basename } from "node:path";
 import { runSupervisor } from "./entries/supervisor.ts";
 import { runStatusline } from "./entries/statusline.ts";
+import { runSubagentStatusline } from "./entries/subagentstatusline.ts";
 import { runStopHook } from "./entries/stophook.ts";
 import { runSessionStart } from "./entries/sessionstart.ts";
 import { cmdInit } from "./cli/init.ts";
 import { cmdAdd } from "./cli/add.ts";
+import { cmdAuth } from "./cli/auth.ts";
 import { cmdCodexAdd } from "./cli/codexadd.ts";
 import { cmdCodexInit } from "./cli/codexinit.ts";
 import { cmdCodexSwitch } from "./cli/codexswitch.ts";
@@ -24,6 +26,7 @@ import { cmdRename } from "./cli/rename.ts";
 import { cmdSwitch } from "./cli/switch.ts";
 import { cmdCheck } from "./cli/check.ts";
 import { cmdConfig } from "./cli/config.ts";
+import { cmdServe } from "./cli/serve.ts";
 import { uninstallSupervisor } from "./lib/install.ts";
 import { c } from "./cli/render.ts";
 
@@ -37,12 +40,14 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing init --codex")}  same for codex: import login, install codex supervisor + Stop hook (trust it via /hooks)
   ${c.cyan("tokenmaxxing add")}        register an additional account (isolated login)
   ${c.cyan("tokenmaxxing add --codex")}   register an additional codex account (isolated login)
+  ${c.cyan("tokenmaxxing auth")} [sel | --all]  reauthenticate a pooled account in place (bare = pick from a list; --all = every needs-reauth account, one by one)
   ${c.cyan("tokenmaxxing switch --codex")} [sel]  switch the codex pool (takes effect on next codex start)
   ${c.cyan("tokenmaxxing ls")}         list pooled accounts
   ${c.cyan("tokenmaxxing status")}     accounts with 5h / weekly / per-model usage bars
   ${c.cyan("tokenmaxxing status --force")}  ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh; ${c.cyan("xx --force")} works too
   ${c.cyan("tokenmaxxing watch")} [seconds]  live status: re-render every N seconds (default 120, never pings)
   ${c.cyan("tokenmaxxing config")} [get|set|unset|tidy]  inspect and edit config.json (bare = effective config with sources)
+  ${c.cyan("tokenmaxxing serve")} [setup|link|unlink|links]  Slack bridge daemon: mention the bot in a linked channel to open a claude session per thread (worktree by default)
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
   ${c.cyan("tokenmaxxing rename")} [--codex] <sel> <label>
   ${c.cyan("tokenmaxxing rm")} <sel>
@@ -70,6 +75,7 @@ async function main(): Promise<number> {
 
   switch (sub) {
     case "__statusline": return runStatusline();
+    case "__subagent-statusline": return runSubagentStatusline();
     case "__stop-hook": return runStopHook();
     case "__session-start": return runSessionStart();
     case "__codex-stop-hook": return runCodexStopHook();
@@ -78,8 +84,10 @@ async function main(): Promise<number> {
     case "switch": return args[1] === "--codex" ? cmdCodexSwitch(args[2]) : cmdSwitch(args[1]);
     case "check": return cmdCheck();
     case "config": return cmdConfig(args.slice(1));
+    case "serve": return cmdServe(args.slice(1));
     case "init": return args.includes("--codex") ? cmdCodexInit() : cmdInit();
     case "add": return args.includes("--codex") ? cmdCodexAdd() : cmdAdd();
+    case "auth": return cmdAuth(args.slice(1));
     case "ls": return cmdLs();
     case "status": return cmdStatus(args.includes("--force"));
     case "watch": return cmdWatch(args[1]);