@mattstack/rt-client 0.10.0 → 0.11.0

package/src/index.ts

@@ -38,6 +38,7 @@ export {
   paneDirectories,
   chatInvite,
   paneSend,
+  paneFocus,
 } from "./client.ts";
 
 export { COMMAND_NAMES } from "./commands.ts";
@@ -75,6 +76,7 @@ export type {
   InviteResult,
   PaneDelivery,
   PaneSendResult,
+  PaneFocusResult,
 } from "./commands.ts";
 
 export { subscribe, createRelay, DEFAULT_WS_URL } from "./relay.ts";
@@ -84,9 +86,12 @@ export { daemonHealth } from "./health.ts";
 
 export { repoNameForPath } from "./repos.ts";
 
+export { decidePlacement, openSmartPane } from "./smart-pane.ts";
+export type { Placement, PlacementOpts, HerdrCall } from "./smart-pane.ts";
+
 // ─── Settings (RT-50) ────────────────────────────────────────────────────────
 
-export { getSetting, listSettings, explainSetting, expandVariables, SCOPE_ORDER } from "./settings/resolve.ts";
+export { getSetting, listSettings, explainSetting, expandVariables, SCOPE_ORDER, setSettingsWarnSink } from "./settings/resolve.ts";
 export type {
   Scope,
   Provenance,

package/src/settings/exec.ts

@@ -12,6 +12,8 @@ export interface RunResult {
   stdout: string;
   stderr: string;
   exitCode: number;
+  /** Set true only when the deadline fired before the child settled. */
+  timedOut?: boolean;
 }
 
 /**
@@ -47,21 +49,53 @@ export async function runCapture(
     return { stdout: "", stderr: "", exitCode: -1 };
   }
 
-  const timer = setTimeout(() => {
-    try { proc.kill(); } catch { /* already exited */ }
-  }, opts.timeoutMs ?? 10_000);
+  const timeoutMs = opts.timeoutMs ?? 10_000;
+  // SIGTERM at the deadline, SIGKILL a short grace later. A child that ignores
+  // SIGTERM (or a D-state descendant) cannot be reaped in-band, so the read is
+  // raced against the deadline below rather than awaited unconditionally: that
+  // is what lets runCapture settle while a grandchild still holds the pipe.
+  let killTimer: ReturnType<typeof setTimeout> | undefined;
+  const term = setTimeout(() => {
+    try { proc.kill("SIGTERM"); } catch { /* already exited */ }
+    killTimer = setTimeout(() => {
+      try { proc.kill("SIGKILL"); } catch { /* already exited */ }
+    }, 2000);
+    // unref: a short-lived CLI process must not be held open by a timed-out
+    // call waiting on this timer; the daemon stays alive regardless, so its
+    // SIGKILL still fires.
+    killTimer.unref?.();
+  }, timeoutMs);
+
+  const captured: Promise<RunResult> = (async () => {
+    try {
+      const stdoutPromise = new Response(proc.stdout as ReadableStream).text();
+      const stderrPromise = captureStderr
+        ? new Response(proc.stderr as ReadableStream).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: ReturnType<typeof setTimeout>;
+  const deadline: Promise<RunResult> = new Promise((resolve) => {
+    deadlineTimer = setTimeout(() => resolve({ stdout: "", stderr: "", exitCode: -1, timedOut: true }), timeoutMs);
+  });
 
   try {
-    const stdoutPromise = new Response(proc.stdout as ReadableStream).text();
-    const stderrPromise = captureStderr
-      ? new Response(proc.stderr as ReadableStream).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!);
+    // killTimer intentionally NOT cleared here: on the timeout path it must
+    // survive this finally to fire SIGKILL against a child that ignored
+    // SIGTERM. proc.kill is already try/catch guarded, so it is a harmless
+    // no-op if the child exited before the 2s grace elapses.
   }
 }

package/src/settings/registry-defs.ts

@@ -44,6 +44,15 @@ export const REGISTRY: readonly SettingDef[] = [
     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",
@@ -196,6 +205,24 @@ export const REGISTRY: readonly SettingDef[] = [
     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",
@@ -205,6 +232,22 @@ export const REGISTRY: readonly SettingDef[] = [
     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.",
+  },
 
   // --- mattstack (installer-lane) -----------------------------------------
   {

package/src/settings/resolve.ts

@@ -487,8 +487,29 @@ function expandCtxFrom(opts: ResolveOpts): ExpandCtx {
   };
 }
 
+let warnSink: ((msg: string) => void) | null = null;
+const warnedOnce = new Set<string>();
+
+/** 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 function setSettingsWarnSink(sink: ((msg: string) => void) | null): void {
+  warnSink = sink;
+  warnedOnce.clear();
+}
+
+export function emitSettingsWarning(msg: string): void {
+  if (warnSink) {
+    if (warnedOnce.has(msg)) return;
+    warnedOnce.add(msg);
+    warnSink(msg);
+    return;
+  }
+  console.warn(msg);
+}
+
 function warnInvalid(key: string, entry: InvalidScope): void {
-  console.warn(
+  emitSettingsWarning(
     `rt: ignoring "${key}" from the ${entry.scope} scope (${entry.file ?? "no file"}): ${entry.reason}`,
   );
 }
@@ -543,7 +564,7 @@ export function listSettings(opts: ResolveOpts = {}): ListedSetting[] {
         listed.value = expandVariables(resolution.value, ctx);
       } catch (err) {
         listed.expandError = (err as Error).message;
-        console.warn(`rt: showing "${def.key}" unexpanded — ${listed.expandError}`);
+        emitSettingsWarning(`rt: showing "${def.key}" unexpanded — ${listed.expandError}`);
       }
     }
 
@@ -583,7 +604,7 @@ function listUnregistered(stores: StoreBundle, opts: ResolveOpts): ListedSetting
   return [...found.entries()]
     .sort(([a], [b]) => a.localeCompare(b))
     .map(([key, hit]) => {
-      console.warn(
+      emitSettingsWarning(
         `rt: unregistered setting "${key}" in ${hit.file} — ignoring it (this rt may be older than the store)`,
       );
       return {

package/src/smart-pane.ts

@@ -0,0 +1,94 @@
+/**
+ * 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 }
+  >;
+}
+
+// A child below these is not worth splitting into; spill to a new tab instead.
+const DEFAULT_MIN_COLS = 50;
+const DEFAULT_MIN_ROWS = 14;
+
+/**
+ * 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 function decidePlacement(
+  rect: { width: number; height: number } | null,
+  opts: PlacementOpts = {},
+): Placement {
+  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" };
+}
+
+/** The anchor pane's rect from a herdr `pane.layout`, or null if unavailable. */
+async function anchorRect(
+  herdr: HerdrCall,
+  anchorPaneId: string,
+): Promise<{ width: number; height: number } | null> {
+  const r = await herdr("pane.layout", { pane_id: anchorPaneId });
+  if (!r.ok) return null;
+  const pane = (r.result?.layout?.panes ?? []).find((p: any) => p.pane_id === anchorPaneId);
+  return pane?.rect ? { width: pane.rect.width, height: pane.rect.height } : null;
+}
+
+/**
+ * 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 async function openSmartPane(
+  herdr: HerdrCall,
+  anchorPaneId: string,
+  opts: { command?: string; focus?: boolean } & PlacementOpts = {},
+): Promise<{ paneId: string; placement: Placement }> {
+  const focus = opts.focus ?? true;
+  const placement = decidePlacement(await anchorRect(herdr, anchorPaneId), opts);
+
+  let paneId: string | undefined;
+  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 };
+}

package/src/transport.ts

@@ -14,6 +14,10 @@ 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 {
@@ -57,7 +61,7 @@ export async function rtCommand<T = unknown>(
     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 ?? 15_000),
       // Bun's `unix` fetch option isn't in the standard RequestInit type.