@mattstack/rt-client 0.10.1 → 0.11.1

package/dist/index.js

@@ -14,7 +14,7 @@ async function rtCommand(cmd, payload, opts = {}) {
     const res = await fetch(`http://localhost/${cmd}`, {
       unix: sockPath,
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: { "Content-Type": "application/json", "X-RT-Client": `rt-client/${process.pid}` },
       body: JSON.stringify(payload),
       signal: AbortSignal.timeout(opts.timeoutMs ?? 15000)
     });
@@ -82,8 +82,19 @@ function chatPost(a, o = {}) {
   const payload = { room: a.room, handle: a.handle, body: a.body };
   if (a.mentions !== undefined)
     payload.mentions = a.mentions;
+  if (a.quiet)
+    payload.quiet = true;
   return rtCommand("chat:post", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
+function chatAck(a, o = {}) {
+  return rtCommand("chat:ack", { id: a.id, handle: a.handle }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
+function chatClaim(a, o = {}) {
+  return rtCommand("chat:claim", { id: a.id, handle: a.handle }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
+function chatRelease(a, o = {}) {
+  return rtCommand("chat:release", { id: a.id, handle: a.handle }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
 function chatRead(a, o = {}) {
   const payload = { handle: a.handle };
   if (a.room !== undefined)
@@ -259,6 +270,9 @@ var COMMAND_NAMES = [
   "runs:list",
   "runs:get",
   "runs:abandon",
+  "chat:ack",
+  "chat:claim",
+  "chat:release",
   "chat:join",
   "chat:leave",
   "chat:post",
@@ -286,7 +300,45 @@ var COMMAND_NAMES = [
   "pane:directories",
   "pane:spawn",
   "pane:send",
-  "pane:focus"
+  "pane:focus",
+  "cache:read",
+  "branch:enrich",
+  "cache:refresh",
+  "daemon:log-level",
+  "ping",
+  "status",
+  "tray:status",
+  "tcc:check",
+  "repos",
+  "ports",
+  "notifications",
+  "discussions:refresh",
+  "discussions:resolve",
+  "discussions:reply",
+  "discussions:diffs",
+  "mr:action",
+  "mr:fetch-job-detail",
+  "mr:fetch-job-trace",
+  "endpoint:claim",
+  "endpoint:lookup",
+  "endpoint:release",
+  "endpoint:status",
+  "repos:locate",
+  "freshness:reconcile",
+  "hooks:repair",
+  "hooks:watch",
+  "sdm:catalog",
+  "sdm:snapshot",
+  "sdm:recents",
+  "sdm:reconnect",
+  "system-processes",
+  "worktree:provision",
+  "worktree:create",
+  "worktree:dispose",
+  "worktree:list",
+  "worktree:restore",
+  "worktree:freshen",
+  "worktree:adopt"
 ];
 // src/relay.ts
 var DEFAULT_WS_URL = "ws://127.0.0.1:9401/ws";
@@ -413,6 +465,56 @@ function repoNameForPath(repoPath, reposJsonPath) {
     return fromDb;
   return repoNameFromJson(repoPath, jsonPath);
 }
+// src/smart-pane.ts
+var DEFAULT_MIN_COLS = 50;
+var DEFAULT_MIN_ROWS = 14;
+function decidePlacement(rect, opts = {}) {
+  const minCols = opts.minCols ?? DEFAULT_MIN_COLS;
+  const minRows = opts.minRows ?? DEFAULT_MIN_ROWS;
+  if (!rect || rect.width <= 0 || rect.height <= 0)
+    return { kind: "split", direction: "right" };
+  const canRight = rect.width >= 2 * minCols;
+  const canDown = rect.height >= 2 * minRows;
+  if (!canRight && !canDown)
+    return { kind: "tab" };
+  if (canRight && canDown) {
+    return rect.width > 2 * rect.height ? { kind: "split", direction: "right" } : { kind: "split", direction: "down" };
+  }
+  return canRight ? { kind: "split", direction: "right" } : { kind: "split", direction: "down" };
+}
+async function anchorRect(herdr, anchorPaneId) {
+  const r = await herdr("pane.layout", { pane_id: anchorPaneId });
+  if (!r.ok)
+    return null;
+  const pane = (r.result?.layout?.panes ?? []).find((p) => p.pane_id === anchorPaneId);
+  return pane?.rect ? { width: pane.rect.width, height: pane.rect.height } : null;
+}
+async function openSmartPane(herdr, anchorPaneId, opts = {}) {
+  const focus = opts.focus ?? true;
+  const placement = decidePlacement(await anchorRect(herdr, anchorPaneId), opts);
+  let paneId;
+  if (placement.kind === "split") {
+    const s = await herdr("pane.split", { pane_id: anchorPaneId, direction: placement.direction, focus });
+    if (!s.ok)
+      throw new Error(`pane.split failed: ${s.message}`);
+    paneId = s.result?.pane?.pane_id;
+    if (!paneId)
+      throw new Error("pane.split returned no pane_id");
+  } else {
+    const workspaceId = anchorPaneId.split(":")[0];
+    const t = await herdr("tab.create", { workspace_id: workspaceId, focus });
+    if (!t.ok)
+      throw new Error(`tab.create failed: ${t.message}`);
+    paneId = t.result?.root_pane?.pane_id;
+    if (!paneId)
+      throw new Error("tab.create returned no pane_id");
+  }
+  if (opts.command) {
+    await herdr("pane.send_text", { pane_id: paneId, text: opts.command });
+    await herdr("pane.send_keys", { pane_id: paneId, keys: ["enter"] });
+  }
+  return { paneId, placement };
+}
 // src/settings/resolve.ts
 import { homedir as homedir4 } from "os";
 import { join as join5 } from "path";
@@ -482,6 +584,15 @@ var REGISTRY = [
     migrated: true,
     description: "Per-repo worktree pool config (onDeck size, ready steps, name pool); root/branchFormat/ready computed-or-empty in the reader."
   },
+  {
+    key: "rt.worktreeReadyApproval",
+    type: "string",
+    scopes: ALL_SCOPES,
+    merge: "replace",
+    repoScoped: true,
+    migrated: true,
+    description: "Per-repo user approval of a team-authored `ready` shell ladder, as its content hash (RT-89). The reader trusts only user/machine scopes so a team store can never approve its own shell; a hash mismatch after a team edit re-holds the ladder until `rt worktree ready-approve` records the new one."
+  },
   {
     key: "rt.repoIdentityOverrides",
     type: "object",
@@ -627,6 +738,24 @@ var REGISTRY = [
     migrated: true,
     description: "Age floor in days for the log janitor pruning every surface's rotated log files under ~/.mattstack/rt/logs (default 14). A fresh key, not an ownership-latch port, so a default is fine here."
   },
+  {
+    key: "rt.logLevel",
+    type: "string",
+    scopes: ["machine", "user"],
+    default: "info",
+    merge: "replace",
+    migrated: true,
+    description: "Daemon log level (trace|debug|info|warn|error). RT_LOG_LEVEL env wins, then this setting, then info (lib/daemon-logger.ts resolveDaemonLogLevel). A fresh key, not an ownership-latch port, so a default is fine here."
+  },
+  {
+    key: "rt.apiPort",
+    type: "number",
+    scopes: ["machine", "user"],
+    default: 9401,
+    merge: "replace",
+    migrated: true,
+    description: "TCP port for the daemon's local HTTP/WS API. Escape hatch when 9401 is held: RT_API_PORT env wins, then this setting, then 9401 (lib/daemon-config.ts resolveApiPort(), read at bind time by lib/daemon/api-server.ts)."
+  },
   {
     key: "rt.hooks",
     type: "object",
@@ -636,6 +765,21 @@ var REGISTRY = [
     migrated: true,
     description: "Per-repo git hook enable/disable state ({enabled, hooks: {<hookName>: boolean}}); ownership-latch port of repos/<repo>/hooks.json, store wins per field once it owns the key — including per-hook-name entries inside the nested hooks map, each defaulting to enabled when absent. The installed git-hook shim still greps repos/<repo>/hooks.json with zero process spawns (a hook fires on every git operation); that file is now a DERIVED CACHE this key writes through, kept current by commands/hooks.ts's regenerateHooksCache at every write seam."
   },
+  {
+    key: "rt.daemonPath",
+    type: "string",
+    scopes: ["machine"],
+    merge: "replace",
+    description: "Absolute colon-separated PATH the daemon uses for every child it spawns, instead of probing your login shell. Set this when the daemon can't find node/git/bun/pnpm (e.g. a fish shell, a blocking .zshrc, or PATH exports that live only in .zshrc). Machine-scoped: it never travels to another machine."
+  },
+  {
+    key: "rt.trustedBrowserOrigins",
+    type: "array",
+    scopes: ["user", "machine"],
+    default: [],
+    merge: "replace",
+    description: "Browser Origins (scheme://host:port, exact string match) trusted to read the :9401 daemon API and subscribe to /ws without presenting the local api-token -- e.g. a locally-hosted console or chat-viewer dev server. Empty by default: every current mattstack consumer (the CLI, the Swift tray, rt-client from Bun/Node processes, the VS Code extension) is a non-browser client (sends no Origin header at all) and is unaffected either way."
+  },
   {
     key: "mattstack.integrations",
     type: "object",
@@ -1296,8 +1440,24 @@ function expandCtxFrom(opts) {
     teamsDir: teamsDir()
   };
 }
+var warnSink = null;
+var warnedOnce = new Set;
+function setSettingsWarnSink(sink) {
+  warnSink = sink;
+  warnedOnce.clear();
+}
+function emitSettingsWarning(msg) {
+  if (warnSink) {
+    if (warnedOnce.has(msg))
+      return;
+    warnedOnce.add(msg);
+    warnSink(msg);
+    return;
+  }
+  console.warn(msg);
+}
 function warnInvalid(key, entry) {
-  console.warn(`rt: ignoring "${key}" from the ${entry.scope} scope (${entry.file ?? "no file"}): ${entry.reason}`);
+  emitSettingsWarning(`rt: ignoring "${key}" from the ${entry.scope} scope (${entry.file ?? "no file"}): ${entry.reason}`);
 }
 function getSetting(key, opts = {}) {
   const def = getDef(key);
@@ -1332,7 +1492,7 @@ function listSettings(opts = {}) {
         listed.value = expandVariables(resolution.value, ctx);
       } catch (err) {
         listed.expandError = err.message;
-        console.warn(`rt: showing "${def.key}" unexpanded — ${listed.expandError}`);
+        emitSettingsWarning(`rt: showing "${def.key}" unexpanded — ${listed.expandError}`);
       }
     }
     out.push(listed);
@@ -1360,7 +1520,7 @@ function listUnregistered(stores, opts) {
   scan("machine", stores.machine.file, stores.machine.global);
   scan("machine.repo", stores.machine.file, repoSection(stores.machine));
   return [...found.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([key, hit]) => {
-    console.warn(`rt: unregistered setting "${key}" in ${hit.file} — ignoring it (this rt may be older than the store)`);
+    emitSettingsWarning(`rt: unregistered setting "${key}" in ${hit.file} — ignoring it (this rt may be older than the store)`);
     return {
       key,
       value: hit.value,
@@ -1585,21 +1745,42 @@ async function runCapture(argv, opts = {}) {
   } catch {
     return { stdout: "", stderr: "", exitCode: -1 };
   }
-  const timer = setTimeout(() => {
+  const timeoutMs = opts.timeoutMs ?? 1e4;
+  let killTimer;
+  const term = setTimeout(() => {
     try {
-      proc.kill();
+      proc.kill("SIGTERM");
     } catch {}
-  }, opts.timeoutMs ?? 1e4);
+    killTimer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+    }, 2000);
+    killTimer.unref?.();
+  }, timeoutMs);
+  const captured = (async () => {
+    try {
+      const stdoutPromise = new Response(proc.stdout).text();
+      const stderrPromise = captureStderr ? new Response(proc.stderr).text() : Promise.resolve("");
+      const [stdout, stderr, exitCode] = await Promise.all([
+        stdoutPromise,
+        stderrPromise,
+        proc.exited
+      ]);
+      return { stdout, stderr, exitCode };
+    } catch {
+      return { stdout: "", stderr: "", exitCode: -1 };
+    }
+  })();
+  let deadlineTimer;
+  const deadline = new Promise((resolve) => {
+    deadlineTimer = setTimeout(() => resolve({ stdout: "", stderr: "", exitCode: -1, timedOut: true }), timeoutMs);
+  });
   try {
-    const stdoutPromise = new Response(proc.stdout).text();
-    const stderrPromise = captureStderr ? new Response(proc.stderr).text() : Promise.resolve("");
-    const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
-    const exitCode = await proc.exited;
-    return { stdout, stderr, exitCode };
-  } catch {
-    return { stdout: "", stderr: "", exitCode: -1 };
+    return await Promise.race([captured, deadline]);
   } finally {
-    clearTimeout(timer);
+    clearTimeout(term);
+    clearTimeout(deadlineTimer);
   }
 }
 
@@ -1722,6 +1903,7 @@ export {
   validateValue,
   unsetSetting,
   subscribe,
+  setSettingsWarnSink,
   setSetting,
   serializeIdentity,
   rtCommand,
@@ -1741,6 +1923,7 @@ export {
   paneFocus,
   paneDirectories,
   paneAccounts,
+  openSmartPane,
   normalizeRemote,
   listTeams,
   listSettings,
@@ -1754,6 +1937,7 @@ export {
   expandVariables,
   eventsHead,
   deriveRepoIdentity,
+  decidePlacement,
   daemonHealth,
   createRelay,
   clearIdentityMemo,
@@ -1761,6 +1945,7 @@ export {
   chatSignOut,
   chatSignIn,
   chatRooms,
+  chatRelease,
   chatRead,
   chatPost,
   chatMessages,
@@ -1770,10 +1955,12 @@ export {
   chatInvite,
   chatDmOpen,
   chatDm,
+  chatClaim,
   chatBuddies,
   chatBack,
   chatAway,
   chatArchive,
+  chatAck,
   allDefs,
   agentStart,
   agentResume,

package/dist/settings/exec.d.ts

@@ -11,6 +11,8 @@ export interface RunResult {
     stdout: string;
     stderr: string;
     exitCode: number;
+    /** Set true only when the deadline fired before the child settled. */
+    timedOut?: boolean;
 }
 /**
  * Run argv and capture stdout. Never throws: spawn failures and timeouts

package/dist/settings/resolve.d.ts

@@ -120,6 +120,11 @@ export interface ExpandCtx {
  * mutates its input.
  */
 export declare function expandVariables(value: unknown, ctx: ExpandCtx): unknown;
+/** The daemon binds a deduped log.warn here so a hot-path getSetting on a
+ *  disallowed-scope key warns once, not every tick. Default: console.warn
+ *  (CLI/test behavior unchanged). null restores the default. */
+export declare function setSettingsWarnSink(sink: ((msg: string) => void) | null): void;
+export declare function emitSettingsWarning(msg: string): void;
 /**
  * Resolves one key across the whole ladder. Throws for an unregistered key —
  * an explicit get of something rt has never heard of is a caller bug, not a

package/dist/smart-pane.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Layout-smart herdr pane placement. `decidePlacement` is pure (geometry ->
+ * where a new pane should go); `openSmartPane` reads an anchor pane's real
+ * rect, decides, and performs the herdr call through an injected caller so it
+ * works over any transport (socket API or a CLI adapter).
+ */
+export type Placement = {
+    kind: "split";
+    direction: "right" | "down";
+} | {
+    kind: "tab";
+};
+export interface PlacementOpts {
+    minCols?: number;
+    minRows?: number;
+}
+export interface HerdrCall {
+    (method: string, params: Record<string, unknown>): Promise<{
+        ok: true;
+        result: any;
+    } | {
+        ok: false;
+        code: string;
+        message: string;
+    }>;
+}
+/**
+ * Where to put a new pane relative to an anchor whose rect (in cells) is given.
+ * Cells are ~2:1 (height:width in px), so a pane is visually wider than tall
+ * when width > 2*height; split the longer visual axis so both halves stay
+ * usable. A null/degenerate rect falls back to a right split (old behavior).
+ */
+export declare function decidePlacement(rect: {
+    width: number;
+    height: number;
+} | null, opts?: PlacementOpts): Placement;
+/**
+ * Open a herdr pane placed intelligently next to `anchorPaneId` (split right or
+ * down, or a new tab when crowded). Optionally run `command` in it. Returns the
+ * new pane id and the placement chosen. Throws on a herdr failure.
+ */
+export declare function openSmartPane(herdr: HerdrCall, anchorPaneId: string, opts?: {
+    command?: string;
+    focus?: boolean;
+} & PlacementOpts): Promise<{
+    paneId: string;
+    placement: Placement;
+}>;

package/dist/transport.d.ts

@@ -2,6 +2,13 @@ export interface RtResponse<T = unknown> {
     ok: boolean;
     data?: T;
     error?: string;
+    /** Structured form of `error` on a handler throw (R035): `code` defaults
+     *  to "handler-threw" when the thrown error carries none. Additive; older
+     *  daemons and the reject path never set this. */
+    failure?: {
+        code: string;
+        message: string;
+    };
 }
 export interface RtClientOptions {
     sockPath?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mattstack/rt-client",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "type": "module",
   "exports": {
     ".": {
@@ -51,5 +51,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2"
   }
 }

package/src/client.ts

@@ -18,6 +18,7 @@ import type {
   WakeMode,
   ChatMember,
   ChatMessage,
+  ChatClaimOutcome,
   RoomSummary,
   BuddyStatus,
   PresenceRow,
@@ -166,12 +167,32 @@ export function chatLeave(
 }
 
 export function chatPost(
-  a: { room: string; handle: string; body: string; mentions?: string[] },
+  a: { room: string; handle: string; body: string; mentions?: string[]; quiet?: boolean },
   o: RtClientOptions = {},
-): Promise<RtResponse<{ id: number; recipients: string[] }>> {
+): Promise<RtResponse<{ id: number; recipients: string[]; others: number }>> {
   const payload: Record<string, unknown> = { room: a.room, handle: a.handle, body: a.body };
   if (a.mentions !== undefined) payload.mentions = a.mentions;
-  return rtCommand<{ id: number; recipients: string[] }>("chat:post", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
+  if (a.quiet) payload.quiet = true;
+  return rtCommand<{ id: number; recipients: string[]; others: number }>("chat:post", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
+}
+
+export function chatAck(
+  a: { id: number; handle: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<{ author: string; room: string; already: boolean }>> {
+  return rtCommand<{ author: string; room: string; already: boolean }>(
+    "chat:ack",
+    { id: a.id, handle: a.handle },
+    { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 },
+  );
+}
+
+export function chatClaim(a: { id: number; handle: string }, o: RtClientOptions = {}): Promise<RtResponse<ChatClaimOutcome>> {
+  return rtCommand<ChatClaimOutcome>("chat:claim", { id: a.id, handle: a.handle }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
+}
+
+export function chatRelease(a: { id: number; handle: string }, o: RtClientOptions = {}): Promise<RtResponse<{ holder: string }>> {
+  return rtCommand<{ holder: string }>("chat:release", { id: a.id, handle: a.handle }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatRead(