@sleep2agi/agent-network 2.3.0-preview.14 → 2.3.0-preview.140

package/dist/src/codex-menu.d.ts

@@ -0,0 +1,78 @@
+export type CodexKind = "co-presence" | "codex-sdk";
+export interface CodexMenuNode {
+    id: string;
+    alias: string;
+    profile: Record<string, any> | null;
+}
+export interface CodexNodeRow {
+    id: string;
+    alias: string;
+    kind: CodexKind;
+    /** "running" | "stopped" | "partial 1/3" … */
+    state: string;
+    running: boolean;
+    loggedIn: boolean;
+    /** Where the login lives: the node's own CODEX_HOME, or the host's ~/.codex. */
+    loginWhere: "node" | "host";
+    /** Absolute CODEX_HOME for `codex login`; null = codex's own default (~/.codex). */
+    codexHome: string | null;
+    threadId: string | null;
+    model: string;
+    modelIsDefault: boolean;
+}
+export interface CollectEnv {
+    nodesDir: string;
+    /** $HOME — only used to locate the host's ~/.codex/auth.json. */
+    home: string;
+    /** The environment a start would inherit (CODEX_HOME); defaults to process.env. */
+    env?: Record<string, string | undefined>;
+    /** Exact tmux session names on the server anet uses (empty when none). */
+    tmuxSessions?: () => Set<string>;
+    pidAlive?: (pid: number) => boolean;
+}
+/** Only codex nodes: co-presence (codex-app-server) and codex-sdk. */
+export declare function collectCodexRows(nodes: CodexMenuNode[], env: CollectEnv): CodexNodeRow[];
+export declare function renderCodexTable(rows: CodexNodeRow[], cwd: string): string;
+export declare const CODEX_CHEAT_SHEET: string;
+export type MenuAction = "start" | "stop" | "restart" | "verify" | "login" | "continue" | "pick" | "model" | "copy" | "delete";
+export declare const MENU_ACTIONS: {
+    key: MenuAction;
+    label: string;
+}[];
+export interface PlannedCommand {
+    /** argv[0] is "anet" (re-invoke this CLI) or "codex". */
+    argv: string[];
+    /** Extra env for the child (only CODEX_HOME for login). */
+    env?: Record<string, string>;
+    /** Shown before the confirm prompt, after the command. */
+    note?: string;
+    /** Shown after the command succeeded. */
+    after?: string;
+}
+export declare function displayQuote(v: string): string;
+export declare function commandLine(cmd: PlannedCommand): string;
+export interface ActionInput {
+    model?: string;
+    newName?: string;
+    workdir?: string;
+}
+/** #528 — not about an existing node: turn a codex conversation started outside anet into a new one. */
+export declare const ADOPT_KEY = "a";
+export declare function planAdopt(newName: string): PlannedCommand;
+export declare function planAction(row: CodexNodeRow, action: MenuAction, input?: ActionInput): PlannedCommand;
+export interface MenuIO {
+    write(s: string): void;
+    /** Resolves to the next line, or null at end of input. */
+    readLine(prompt: string): Promise<string | null>;
+}
+export type Runner = (cmd: PlannedCommand) => Promise<number>;
+/** Returns the process exit code. Runs at most one command. */
+export declare function codexMenu(rows: CodexNodeRow[], io: MenuIO, run: Runner, ctx: {
+    cwd: string;
+}): Promise<number>;
+/** Entry from cli.ts (`anet node codex` with no arguments). Returns the exit code. */
+export declare function runCodexMenu(nodes: CodexMenuNode[], opts: {
+    nodesDir: string;
+    home: string;
+    cwd?: string;
+}): Promise<number>;

package/dist/src/codex-model-default.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_CODEX_MODEL = "gpt-5.6-sol";
+export declare const CODEX_MODEL_CHOICES: ReadonlyArray<{
+    readonly id: string;
+    readonly default?: boolean;
+}>;
+export declare function defaultCodexModelForRuntime(runtime: string): string | undefined;

package/dist/src/codex-node-login.d.ts

@@ -0,0 +1,98 @@
+export type CodexLoginKind = "chatgpt" | "api-key" | "none" | "unreadable";
+export interface CodexLoginFacts {
+    readonly loggedIn: boolean;
+    readonly kind: CodexLoginKind;
+    /** #1918 refresh-chain fingerprint (8 hex) — what actually collides. */
+    readonly loginFingerprint: string | null;
+    /** #1856 account fingerprint (sha256(account_id), 16 hex). */
+    readonly accountFingerprint: string | null;
+    /** `email` claim of the id_token, when present. Not a credential. */
+    readonly email: string | null;
+}
+/** What an auth.json says about a login — without ever returning a token. */
+export declare function codexLoginFactsFromText(text: string | null): CodexLoginFacts;
+export declare function codexLoginFactsOfHome(codexHome: string): CodexLoginFacts;
+export interface NodeConfigLike {
+    runtime?: unknown;
+    codexCopresence?: unknown;
+    codexHome?: unknown;
+    env?: unknown;
+    alias?: unknown;
+    node_name?: unknown;
+    name?: unknown;
+}
+/** A node whose runtime runs codex. */
+export declare function isCodexNodeConfig(cfg: NodeConfigLike | null | undefined): boolean;
+export type EffectiveCodexHomeSource = "config.codexHome" | "node-codex-home" | "config.env" | "environment" | "default";
+/**
+ * The CODEX_HOME this node's codex process will get — the same decision
+ * `applyNodeCodexHome` makes on start: the node's own value; otherwise an
+ * inherited CODEX_HOME unless it is another node's codex-home; otherwise
+ * codex's default `~/.codex`.
+ */
+export declare function effectiveCodexHome(nodeDir: string, cfg: NodeConfigLike | null, env: Record<string, string | undefined>, home: string): {
+    codexHome: string;
+    source: EffectiveCodexHomeSource;
+};
+export interface LoginNextStepInput {
+    readonly alias: string;
+    readonly codexHome: string;
+    /** Does the codex-home directory exist yet? codex 0.133 refuses a CODEX_HOME that does not. */
+    readonly homeExists: boolean;
+    /** e.g. `anet node start <alias>`; printed as what comes after the login. */
+    readonly then?: string;
+}
+/**
+ * The one next step for a codex node without a login. Plain text, no token,
+ * nothing executed. `--device-auth` is in `codex login --help` of the pinned
+ * codex (agent-node depends on @openai/codex ^0.133; checked on 0.133.0).
+ */
+export declare function codexLoginNextStepLines(i: LoginNextStepInput): string[];
+export interface CreateLoginGapInput {
+    readonly nodeDir: string;
+    readonly config: NodeConfigLike | null;
+    readonly env: Record<string, string | undefined>;
+    readonly home: string;
+    /**
+     * For a co-presence node whose own codex-home has no login: would its first
+     * start be allowed to stage the host login (#514 gate says "ok")? Injected so
+     * this stays a pure decision; the CLI passes evaluateCodexLoginStaging.
+     */
+    readonly hostLoginWouldBeStaged: (hostAuthPath: string) => boolean;
+}
+/** null = the node will have a usable login; otherwise the CODEX_HOME to log in. */
+export declare function codexCreateLoginGap(i: CreateLoginGapInput): {
+    codexHome: string;
+    homeExists: boolean;
+} | null;
+export interface CodexLoginStatusRow {
+    alias: string;
+    node_id: string | null;
+    runtime: string;
+    copresence: boolean;
+    codex_home: string;
+    codex_home_source: EffectiveCodexHomeSource;
+    logged_in: boolean;
+    login_kind: CodexLoginKind;
+    /** #1918 refresh-chain fingerprint (8 hex). */
+    login_fingerprint: string | null;
+    /** #1856 account fingerprint (16 hex). */
+    account_fingerprint: string | null;
+    email: string | null;
+    /** Other nodes holding the SAME refresh chain — they log each other out. */
+    shared_with: string[];
+    /** Other nodes logged in to the same account with their OWN login — fine. */
+    same_account_as: string[];
+}
+export interface LoginStatusOptions {
+    /** `<workspace>/.anet/nodes` */
+    readonly nodesRoot: string;
+    readonly env: Record<string, string | undefined>;
+    readonly home: string;
+    /** Host index of published fingerprints (#1918); default under `home`. */
+    readonly indexDir?: string;
+}
+/** One row per codex node under `nodesRoot`. Read-only. */
+export declare function codexNodeLoginStatus(o: LoginStatusOptions): CodexLoginStatusRow[];
+/** Human table. Never contains a token: rows carry none. */
+export declare function formatCodexLoginStatus(rows: readonly CodexLoginStatusRow[], workspace: string): string[];

package/dist/src/codex-resume.d.ts

@@ -0,0 +1,89 @@
+import { type ExternalThread } from "./codex-adopt";
+import { type CollectEnv, type CodexMenuNode } from "./codex-menu";
+export type CodexResumeKind = "co-presence" | "codex-sdk";
+export interface CodexResumeFacts {
+    readonly alias: string;
+    readonly kind: CodexResumeKind;
+    /** "running" | "stopped" | "partial 1/3" (codex-menu's row.state). */
+    readonly state: string;
+    readonly running: boolean;
+    /** The CODEX_HOME the node's codex runs with (its own, or the host ~/.codex for a codex-sdk node). */
+    readonly codexHome: string;
+    readonly homeExists: boolean;
+    /** true = codex's default ~/.codex (no CODEX_HOME needed to log it in). */
+    readonly homeIsHost: boolean;
+    readonly loggedIn: boolean;
+    /** codexThreadId (co-presence) / session (codex-sdk) from the node config. */
+    readonly recordedThread: string | null;
+    /** Every rollout under `<codexHome>/sessions`, newest first. */
+    readonly threads: readonly ExternalThread[];
+}
+export interface CodexResumeRequest {
+    /** --thread <id|unique prefix> (also --session <id>, the old spelling). */
+    readonly thread?: string | null;
+    readonly pick?: boolean;
+    /** stdin and stdout are both a terminal. */
+    readonly tty: boolean;
+}
+export type CodexResumeDecision = 
+/** Nothing was done. `lines[0]` is the reason with the fix; exit with `code`. */
+{
+    readonly kind: "refuse";
+    readonly code: number;
+    readonly lines: readonly string[];
+}
+/** --pick without a terminal: the list plus a copy-paste command. Nothing was done. */
+ | {
+    readonly kind: "list";
+    readonly code: number;
+    readonly lines: readonly string[];
+}
+/** --pick in a terminal: show `lines`, ask for a number in 1..`choices.length`. */
+ | {
+    readonly kind: "ask";
+    readonly lines: readonly string[];
+    readonly choices: readonly string[];
+}
+/** Already running on exactly that thread — attach instead (exit 0). */
+ | {
+    readonly kind: "already";
+    readonly lines: readonly string[];
+}
+/** Go: record `threadId` (when `changed`) and start the node. */
+ | {
+    readonly kind: "resume";
+    readonly threadId: string;
+    readonly changed: boolean;
+    readonly rolloutPath: string;
+};
+/** How many threads the picker numbers; older ones are reachable with --thread. */
+export declare const PICK_LIMIT = 20;
+export declare function freshStartCommand(f: Pick<CodexResumeFacts, "alias" | "kind">): string;
+export declare function codexLoginCommand(f: Pick<CodexResumeFacts, "codexHome" | "homeIsHost">): string;
+/** Numbered rows: time (UTC, as codex wrote it), short id, first user line. The recorded thread is marked. */
+export declare function formatNodeThreadList(threads: readonly ExternalThread[], recorded: string | null, limit?: number): string[];
+export declare function resumeCommandFor(alias: string, threadId: string): string;
+/** The whole decision. Order: request shape → home → which thread → login → process state. */
+export declare function decideCodexResume(f: CodexResumeFacts, req: CodexResumeRequest): CodexResumeDecision;
+/** A typed answer to the picker: a number from the list; empty / q = cancel. */
+export declare function parsePickAnswer(answer: string | null, choices: readonly string[]): {
+    kind: "ok";
+    threadId: string;
+} | {
+    kind: "cancel";
+} | {
+    kind: "bad";
+    message: string;
+};
+/**
+ * `anet node codex resume` records the thread in config before its state
+ * machine runs. If the run stops before anything was touched, the old value
+ * goes back — the config must not name a thread the node is not running (#531 §5).
+ */
+export declare function resumeConfigShouldRollBack(stoppedAt: string): boolean;
+/**
+ * The facts for one node, from the same helpers the codex menu uses
+ * (collectCodexRows: kind / state / login; effectiveCodexHome: which home).
+ * Read-only. null = not a codex node.
+ */
+export declare function gatherCodexResumeFacts(node: CodexMenuNode, env: CollectEnv): CodexResumeFacts | null;

package/dist/src/codex-tui-client-health.d.ts

@@ -0,0 +1,30 @@
+export declare function bridgeClientHealthReceipt(remote: string, threadId: string): string;
+export interface MigratedCodexPendingThread {
+    version: 1;
+    threadId: string;
+    serverUrl: string;
+    marker: string;
+}
+/**
+ * Move a crash-window deferred candidate onto the launcher's new owned
+ * app-server generation. The old URL is an authority supplied by the same
+ * private node config, not by the pending object itself; every mismatch is a
+ * hard stop so restart never guesses or adopts a second thread.
+ */
+export declare function migrateCodexPendingThread(value: unknown, oldServerUrl: unknown, expectedOldMarker: unknown, newServerUrl: string, newMarker: string): MigratedCodexPendingThread;
+export declare function requirePromotedCodexPendingThread(value: unknown, pendingThreadId: string): string;
+/**
+ * argv for the human TUI attached to the co-presence app-server.
+ *
+ * #505 — the permission override is only passed on the FRESH path. On
+ * `resume --remote <ws> <thread>` codex 0.155.1 exits immediately with
+ *   "Error: Permission overrides are not supported when resuming a remote task."
+ * (anet then reports "TUI tmux session exited during startup"). Measured in
+ * Docker against a real app-server + real thread: 0.155.1 rejects
+ * resume + --dangerously-bypass-approvals-and-sandbox and accepts it fresh
+ * (TUI up, "permissions: YOLO mode"); 0.133.0 (agent-node's pin) accepts both.
+ * Nothing is lost by dropping it on resume: the app-server itself is started
+ * with `-c approval_policy=… -c sandbox_mode=…` from the same posture.
+ */
+export declare function codexTuiLaunchArgs(remote: string, model: string, threadId?: string, dangerFullAccess?: boolean): string[];
+export declare function assertPendingServerQuiesced(serverUrl: unknown, isListening: (port: number) => boolean | Promise<boolean>): Promise<void>;

package/dist/src/commhub-response.d.ts

@@ -0,0 +1 @@
+export declare function parseCommhubToolResult(json: any): any;

package/dist/src/controlled-upload.d.ts

@@ -0,0 +1,83 @@
+/**
+ * #693 — token-bound node controlled local file → Hub /api/upload bridge.
+ *
+ * Security boundary (hard gates):
+ *  1. Cross-host: bytes travel over HTTP multipart; Hub never reads agent FS.
+ *  2. Identity: caller supplies the node's bearer token; ntok binds network.
+ *  3. Path safety: realpath + allowlisted roots; reject NUL, symlink, traversal.
+ *  4. Size ≤ 12 MiB enforced with same-fd fstat + bounded read (no full slurp).
+ *  5. Hub /api/upload is the sole write surface (atomic on hub side).
+ *
+ * Adversarial add-only (#694 DO-NOT-MERGE fixes):
+ *  - TOCTOU: open O_NOFOLLOW → fstat(fd) → read(fd) only; no re-open by path.
+ *  - Bounded read: never allocate/read past CONTROLLED_UPLOAD_MAX_BYTES.
+ *  - NUL guard is live and reachable before any fs call.
+ */
+/** Mirrors server/src/uploads.ts MAX_UPLOAD_BYTES. */
+export declare const CONTROLLED_UPLOAD_MAX_BYTES: number;
+/** Chunk size for bounded streaming read from a single fd. */
+export declare const CONTROLLED_UPLOAD_READ_CHUNK: number;
+export type ControlledUploadErrorCode = "path_required" | "path_nul" | "path_not_found" | "path_untrusted" | "path_symlink" | "path_not_regular" | "path_empty" | "payload_too_large" | "read_failed" | "auth_required" | "hub_url_required" | "upload_failed" | "bad_response" | "missing_file_id";
+export type ControlledUploadFail = {
+    ok: false;
+    error: ControlledUploadErrorCode;
+    message: string;
+};
+export type ControlledUploadOk = {
+    ok: true;
+    file_id: string;
+    name: string;
+    mime: string;
+    size: number;
+    url?: string;
+};
+export type ControlledUploadResult = ControlledUploadOk | ControlledUploadFail;
+export interface ControlledUploadDeps {
+    hubUrl: string;
+    authToken: string;
+    allowedRoots?: string[];
+    alias?: string;
+    nodeDir?: string;
+    fetch?: typeof fetch;
+    home?: string;
+}
+/** Normalize a client filename: basename only, strip controls, cap 255. */
+export declare function normalizeUploadName(input: string | undefined | null, fallback?: string): string;
+export declare function defaultControlledUploadRoots(opts?: {
+    home?: string;
+    alias?: string;
+    nodeDir?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): string[];
+/** True iff canonicalPath is strictly inside one of the allowlisted roots. */
+export declare function isPathInsideAllowedRoots(canonicalPath: string, allowedRoots: string[]): boolean;
+/**
+ * Resolve a user-supplied path to a canonical path under an allowlisted root.
+ * Does not open the file for reading — open+fstat+read is a separate same-fd step.
+ */
+export declare function resolveControlledUploadPath(rawPath: string, allowedRoots: string[]): {
+    ok: true;
+    canonicalPath: string;
+} | ControlledUploadFail;
+export type ControlledFileBytes = {
+    ok: true;
+    bytes: Buffer;
+    size: number;
+    canonicalPath: string;
+} | ControlledUploadFail;
+/**
+ * Open → fstat(fd) → bounded read(fd) on the **same fd** (TOCTOU hard gate).
+ * Uses O_NOFOLLOW when available so a symlink swap at open is rejected.
+ * Never uses path-based readFileSync after the initial open.
+ */
+export declare function openFstatBoundedReadControlledFile(canonicalPath: string, allowedRoots: string[], maxBytes?: number): ControlledFileBytes;
+/**
+ * Upload a controlled local file to Hub POST /api/upload.
+ * Returns file_id + metadata for send_reply attachments.
+ * Never falls back to sending a raw path to the Hub.
+ */
+export declare function uploadControlledLocalFile(rawPath: string, deps: ControlledUploadDeps, opts?: {
+    name?: string;
+    mime?: string;
+}): Promise<ControlledUploadResult>;

package/dist/src/copresence-deps.d.ts

@@ -0,0 +1,22 @@
+export interface CopresenceDep {
+    readonly name: string;
+    readonly present: boolean;
+    /** Exact command for this platform, or null when we cannot name one. */
+    readonly install: string | null;
+    readonly why: string;
+}
+export type CommandProbe = (cmd: string) => boolean;
+/** Which agent binary this co-presence lane is built on. */
+export type CopresenceAgent = "codex" | "grok";
+export declare function copresenceDeps(probe: CommandProbe, platform?: NodeJS.Platform, agent?: CopresenceAgent): CopresenceDep[];
+export declare function missingCopresenceDeps(probe: CommandProbe, platform?: NodeJS.Platform, agent?: CopresenceAgent): CopresenceDep[];
+/** One block naming every gap and how to close it — never one gap at a time. */
+export declare function describeMissingDeps(missing: readonly CopresenceDep[], displayName: string): string;
+/**
+ * May we start this hub ourselves?
+ *
+ * Only a loopback hub. A remote URL that refuses the connection is somebody
+ * else's service — spawning a local one would silently point the node at a
+ * DIFFERENT hub than its profile names, which is worse than failing.
+ */
+export declare function isLoopbackHub(hubUrl: string): boolean;