@mattstack/rt-client 0.2.0 → 0.4.0

package/README.md

@@ -17,8 +17,11 @@ const repos = await rtCommand(['repos', 'list']);
 const mrs = await readProjectMRs('group/repo');
 ```
 
-Requires a running rt daemon. Install rt with `brew install m4ttheweric/tap/rt`,
-then `rt verify`.
+Requires a running rt daemon. Install rt from the latest GitHub Release
+(`./rt --post-install`), then `rt verify`.
+
+Bun-only: the settings exec path (`src/settings/exec.ts`) shells out via
+`Bun.spawn`, so this package does not run under Node.
 
 `@mattstack/glance` is a peer dependency: rt-client returns glance's forge types
 so merge request shapes stay identical across rt, gitq, and mr-board.

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import type { RtResponse, RtClientOptions } from "./transport.ts";
-import type { DemandDecl, ProjectMRsData, DiscussionsData, MrByBranchData, ForgeSlug, ForgeTokenData } from "./commands.ts";
+import type { DemandDecl, ProjectMRsData, DiscussionsData, MrByBranchData, ForgeSlug, ForgeTokenData, RunSummary, RunDetail, WakeMode, ChatMember, ChatMessage, RoomSummary } from "./commands.ts";
 /**
  * One repo's project open-MR store. A cold repo forces a full paginated sync
  * on the daemon side when maxAgeMs demands it, which can run tens of seconds
@@ -18,6 +18,97 @@ export declare function readMrsByBranch(repoName: string, branches: string[], op
  * side: an untracked repo comes back `ok: false` with the `rt daemon track`
  * command to run, which is the fail-closed shape callers should surface
  * verbatim. Callers keep env-var precedence on their own side; this is the
- * fallback that replaces reading ~/.rt/secrets.json directly.
+ * fallback that replaces reading ~/.mattstack/rt/secrets.json directly.
  */
 export declare function resolveForgeToken(repoName: string, forge: ForgeSlug, opts?: RtClientOptions): Promise<RtResponse<ForgeTokenData>>;
+export declare function listRuns(repo?: string, opts?: RtClientOptions): Promise<RtResponse<{
+    runs: RunSummary[];
+}>>;
+export declare function getRun(runId: string, repo?: string, opts?: RtClientOptions): Promise<RtResponse<RunDetail>>;
+/**
+ * SKILLS-54. rt's only write path into run state, so a wedged run can be
+ * resolved by a person instead of lying in the data forever. The write happens
+ * in the daemon and is attributed there; consumers never touch the run DB.
+ */
+export declare function abandonRun(runId: string, repo?: string, reason?: string, opts?: RtClientOptions): Promise<RtResponse<{
+    ok: boolean;
+}>>;
+export declare function chatJoin(a: {
+    room: string;
+    handle: string;
+    wakeOn?: WakeMode;
+    cwd?: string;
+    pane?: string;
+}, o?: RtClientOptions): Promise<RtResponse<{
+    handle: string;
+    memberCount: number;
+    unread: number;
+}>>;
+export declare function chatLeave(a: {
+    room: string;
+    handle: string;
+}, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
+export declare function chatPost(a: {
+    room: string;
+    handle: string;
+    body: string;
+}, o?: RtClientOptions): Promise<RtResponse<{
+    id: number;
+    recipients: string[];
+}>>;
+export declare function chatRead(a: {
+    handle: string;
+    room?: string;
+    limit?: number;
+    sinceMs?: number;
+}, o?: RtClientOptions): Promise<RtResponse<{
+    rooms: {
+        room: string;
+        messages: ChatMessage[];
+    }[];
+}>>;
+export declare function chatRooms(a: {
+    handle: string;
+}, o?: RtClientOptions): Promise<RtResponse<{
+    rooms: RoomSummary[];
+}>>;
+export declare function chatWho(a: {
+    room: string;
+}, o?: RtClientOptions): Promise<RtResponse<{
+    members: ChatMember[];
+}>>;
+export declare function chatMark(a: {
+    handle: string;
+    room?: string;
+}, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
+export declare function chatMessages(a: {
+    room: string;
+    before?: number;
+    limit?: number;
+}, o?: RtClientOptions): Promise<RtResponse<{
+    messages: ChatMessage[];
+}>>;
+export declare function chatArm(a: {
+    handle: string;
+    room?: string;
+}, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
+export declare function chatTouch(a: {
+    handle: string;
+}, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
+export declare function chatDisarm(a: {
+    handle: string;
+}, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
+export declare function chatUnreadWaking(a: {
+    handle: string;
+    room?: string;
+}, o?: RtClientOptions): Promise<RtResponse<{
+    rooms: {
+        room: string;
+        count: number;
+        mentions: number;
+        maxId: number;
+    }[];
+}>>;
+export declare function eventsHead(o?: RtClientOptions): Promise<RtResponse<{
+    cursor: number;
+}>>;

package/dist/commands.d.ts

@@ -45,6 +45,106 @@ export type ForgeSlug = "gitlab" | "github";
 export interface ForgeTokenData {
     token: string;
 }
+/**
+ * Duplicated shape on purpose (RT-44): rt-client cannot import daemon
+ * internals, so this mirrors lib/daemon/events-bus.ts's BusEvent.
+ */
+export interface EventsBusEvent {
+    id: number;
+    topic: string;
+    payload: unknown;
+    emittedAt: number;
+}
+/**
+ * Duplicated shape on purpose, same reasoning as EventsBusEvent above:
+ * these mirror lib/state/chat-store.ts's types, which rt-client cannot
+ * import (it's outside lib/state/ and outside this package entirely).
+ */
+export type WakeMode = "mention" | "all" | "none";
+export interface ChatMember {
+    room: string;
+    handle: string;
+    joinedAt: number;
+    lastReadId: number;
+    wakeOn: WakeMode;
+    lastSeenAt?: number;
+    armedAt?: number;
+    cwd?: string;
+    pane?: string;
+}
+export interface ChatMessage {
+    id: number;
+    room: string;
+    handle: string;
+    body: string;
+    mentions: string[];
+    replyTo?: number;
+    postedAt: number;
+}
+export interface RoomSummary {
+    room: string;
+    memberCount: number;
+    unread: number;
+    mentions: number;
+    lastPostedAt?: number;
+}
+export type Attention = {
+    needs: boolean;
+    reason: "failed" | "stale" | "stranded" | null;
+    evidence: string;
+};
+export interface RunSummary {
+    id: string;
+    repo: string;
+    work_type: string;
+    pipeline: string;
+    status: string;
+    current_stage: string | null;
+    spawned_by: string | null;
+    started_at: number;
+    ended_at: number | null;
+    pack_commits: string | null;
+    pack_dirty: number;
+    attention: Attention;
+    /** Max over stage, field, and decision timestamps; falls back to
+        `started_at` when the run has produced no events yet. The board orders
+        by silence, so this — not `started_at` — is its sort key. */
+    last_event_at: number;
+    /** Denormalized from the run's `ticket` / `branch` fields so the LIST view
+        can render and search them without a detail fetch per row. Null when
+        the run has not produced that field yet. */
+    ticket: string | null;
+    branch: string | null;
+}
+export interface RunStageRow {
+    name: string;
+    status: string;
+    attempt: number;
+    started_at: number | null;
+    ended_at: number | null;
+    reason: string | null;
+    detail_path: string | null;
+}
+export interface RunFieldRow {
+    key: string;
+    value: string;
+    produced_by: string;
+    at: number;
+}
+export interface RunDecisionRow {
+    contract: string;
+    scope: string;
+    selection: string;
+    decided_by: string;
+    decided_at: number;
+}
+export interface RunDetail {
+    run: RunSummary;
+    stages: RunStageRow[];
+    fields: RunFieldRow[];
+    decisions: RunDecisionRow[];
+    schemaAhead: boolean;
+}
 export interface Commands {
     "project-mrs:read": {
         payload: {
@@ -71,7 +171,7 @@ export interface Commands {
     /**
      * The forge token for one tracked repo (MAT-33). Repo-scoped on purpose:
      * rt gates access per repo through repo-tracking.json, and this verb is
-     * what lets consumers stop reading ~/.rt/secrets.json directly, which
+     * what lets consumers stop reading ~/.mattstack/rt/secrets.json directly, which
      * walked around that grant model entirely. An untracked repo is refused;
      * the caller's env vars keep precedence on the caller's side.
      */
@@ -82,6 +182,223 @@ export interface Commands {
         };
         data: ForgeTokenData;
     };
+    /**
+     * A per-`scope` whitelisted subset of secrets, each scope reading its own
+     * encrypted domain(s): "extension" (default, so the VS Code extension
+     * needs no change) is linearApiKey/gitlabToken from the `rt` domain;
+     * "deck" is cfApiToken/cfZoneId from the `deck` domain; "board" is
+     * cross-domain — slackToken/slackClientSecret/slackSigningSecret from the
+     * `board` domain plus gitlabToken/switchboardToken/switchboardAdminToken
+     * from the `rt` domain. `data` is a union of the per-scope shapes, not a
+     * merged bag of every key — that makes a caller narrowing on the wrong
+     * scope's fields a compile error instead of a silent `undefined`. Every
+     * key optional (present only when set). Not a general secrets export —
+     * extend a whitelist here, in lockstep with
+     * lib/daemon/handlers/secrets.ts and (for "extension")
+     * extensions/vscode/rt-context/src/secrets.ts, if a consumer needs another
+     * key.
+     *
+     * `token` is required and checked in the HANDLER (not a transport-layer
+     * gate alone), since this verb is reachable over the unauthenticated unix
+     * socket too — see lib/daemon/handlers/secrets.ts's doc comment. HTTP
+     * callers get it forwarded automatically from their X-RT-Token header;
+     * socket callers must read ~/.mattstack/rt/api-token themselves. The gate
+     * applies identically to every scope.
+     */
+    "secrets:read": {
+        payload: {
+            token?: string;
+            scope?: "extension" | "deck" | "board";
+        };
+        data: {
+            linearApiKey?: string;
+            gitlabToken?: string;
+        } | {
+            cfApiToken?: string;
+            cfZoneId?: string;
+        } | {
+            slackToken?: string;
+            slackClientSecret?: string;
+            slackSigningSecret?: string;
+            gitlabToken?: string;
+            switchboardToken?: string;
+            switchboardAdminToken?: string;
+        };
+    };
+    "events:emit": {
+        payload: {
+            topic: string;
+            payload?: unknown;
+        };
+        data: {
+            id: number;
+        };
+    };
+    "events:wait": {
+        payload: {
+            pattern: string;
+            after?: number;
+            waitMs?: number;
+        };
+        data: {
+            events: EventsBusEvent[];
+            cursor: number;
+        };
+    };
+    "events:list": {
+        payload: {
+            pattern: string;
+            after?: number;
+            limit?: number;
+        };
+        data: {
+            events: EventsBusEvent[];
+            cursor: number;
+        };
+    };
+    "events:head": {
+        payload: Record<string, never>;
+        data: {
+            cursor: number;
+        };
+    };
+    "runs:list": {
+        payload: {
+            repo?: string;
+        };
+        data: {
+            runs: RunSummary[];
+        };
+    };
+    "runs:get": {
+        payload: {
+            runId: string;
+            repo?: string;
+        };
+        data: RunDetail;
+    };
+    "runs:abandon": {
+        payload: {
+            runId: string;
+            repo?: string;
+            reason?: string;
+        };
+        data: {
+            ok: boolean;
+        };
+    };
+    "chat:join": {
+        payload: {
+            room: string;
+            handle: string;
+            wakeOn?: WakeMode;
+            cwd?: string;
+            pane?: string;
+        };
+        data: {
+            handle: string;
+            memberCount: number;
+            unread: number;
+        };
+    };
+    "chat:leave": {
+        payload: {
+            room: string;
+            handle: string;
+        };
+        data: Record<string, never>;
+    };
+    "chat:post": {
+        payload: {
+            room: string;
+            handle: string;
+            body: string;
+        };
+        data: {
+            id: number;
+            recipients: string[];
+        };
+    };
+    "chat:read": {
+        payload: {
+            handle: string;
+            room?: string;
+            limit?: number;
+            sinceMs?: number;
+        };
+        data: {
+            rooms: {
+                room: string;
+                messages: ChatMessage[];
+            }[];
+        };
+    };
+    "chat:rooms": {
+        payload: {
+            handle: string;
+        };
+        data: {
+            rooms: RoomSummary[];
+        };
+    };
+    "chat:who": {
+        payload: {
+            room: string;
+        };
+        data: {
+            members: ChatMember[];
+        };
+    };
+    "chat:mark": {
+        payload: {
+            handle: string;
+            room?: string;
+        };
+        data: Record<string, never>;
+    };
+    "chat:messages": {
+        payload: {
+            room: string;
+            before?: number;
+            limit?: number;
+        };
+        data: {
+            messages: ChatMessage[];
+        };
+    };
+    "chat:arm": {
+        payload: {
+            handle: string;
+            room?: string;
+        };
+        data: Record<string, never>;
+    };
+    "chat:touch": {
+        payload: {
+            handle: string;
+        };
+        data: Record<string, never>;
+    };
+    "chat:disarm": {
+        payload: {
+            handle: string;
+        };
+        data: Record<string, never>;
+    };
+    "chat:unread-waking": {
+        payload: {
+            handle: string;
+            room?: string;
+        };
+        data: {
+            rooms: {
+                room: string;
+                count: number;
+                mentions: number;
+                maxId: number;
+            }[];
+        };
+    };
 }
 export type CommandName = keyof Commands;
 export declare const COMMAND_NAMES: readonly CommandName[];

package/dist/index.d.ts

@@ -1,8 +1,18 @@
 export { rtCommand, DEFAULT_SOCK } from "./transport.ts";
 export type { RtResponse, RtClientOptions } from "./transport.ts";
-export { readProjectMRs, readDiscussions, readMrsByBranch, resolveForgeToken } from "./client.ts";
+export { readProjectMRs, readDiscussions, readMrsByBranch, resolveForgeToken, listRuns, getRun, abandonRun, chatJoin, chatLeave, chatPost, chatRead, chatRooms, chatWho, chatMark, chatMessages, chatArm, chatTouch, chatDisarm, chatUnreadWaking, eventsHead, } from "./client.ts";
 export { COMMAND_NAMES } from "./commands.ts";
-export type { Discussion, DemandDecl, ProjectMRsScope, ProjectMRsData, DiscussionsData, MrByBranchEntry, MrByBranchData, Commands, CommandName, ForgeSlug, ForgeTokenData, } from "./commands.ts";
+export type { Discussion, DemandDecl, ProjectMRsScope, ProjectMRsData, DiscussionsData, MrByBranchEntry, MrByBranchData, Commands, CommandName, ForgeSlug, ForgeTokenData, Attention, RunSummary, RunStageRow, RunFieldRow, RunDecisionRow, RunDetail, WakeMode, ChatMember, ChatMessage, RoomSummary, } from "./commands.ts";
 export { subscribe, DEFAULT_WS_URL } from "./relay.ts";
 export type { RelayEventType } from "./relay.ts";
 export { repoNameForPath } from "./repos.ts";
+export { getSetting, listSettings, explainSetting, expandVariables, SCOPE_ORDER } from "./settings/resolve.ts";
+export type { Scope, Provenance, ResolveOpts, Resolved, InvalidScope, ListedSetting, ExplainRow, ExpandCtx, } from "./settings/resolve.ts";
+export { setSetting } from "./settings/write.ts";
+export type { SetSettingOpts } from "./settings/write.ts";
+export { getDef, allDefs, validateValue, isMigrated } from "./settings/registry-machinery.ts";
+export type { SettingDef, SettingScope } from "./settings/registry-machinery.ts";
+export { REGISTRY } from "./settings/registry-defs.ts";
+export { readStore, listTeams } from "./settings/stores.ts";
+export type { StoreFile } from "./settings/stores.ts";
+export { normalizeRemote, identityFromRemote, deriveRepoIdentity, clearIdentityMemo, serializeIdentity, parseIdentity, resolveNameToIdentity, type RepoIdentity, } from "./settings/identity.ts";