@sleep2agi/agent-network 2.3.0-preview.16 → 2.3.0-preview.161

package/dist/src/node-remote.d.ts

@@ -0,0 +1,180 @@
+/**
+ * #562 step 2 — remote lifecycle: act on a node that lives on ANOTHER machine.
+ *
+ *   anet node start   <alias> --remote [--network <id|name>] [--yes] [--wait <s>]
+ *   anet node stop    <alias> --remote [--network <id|name>] [--yes] [--wait <s>] [--force]
+ *   anet node restart <alias> --remote [--network <id|name>] [--yes] [--wait <s>]
+ *   anet node edit    <alias> --model <id> --remote [--network <id|name>] [--yes] [--wait <s>]
+ *
+ * Nothing new on the Hub: these are the same MCP tools the app calls (POST /mcp tools/call):
+ *   start   → start_node          Hub → that machine's daemon (host_supervisor) spawns the child
+ *   stop    → stop_node           Hub → that machine's daemon stops the child
+ *   restart → restart_node        Hub → the node itself drains + exits 75; its `anet node start`
+ *                                 wrapper respawns it (whoever ran that wrapper: a daemon or a person)
+ *   edit    → update_node_config  same doorbell; a model change is restart-tier
+ * Permission checks are the Hub's (canWrite: member+, not viewer, not agent-restricted); this
+ * module never decides who may do what — it only refuses what cannot work, BEFORE dispatching:
+ *   start/stop (need the machine's daemon):
+ *   - no online daemon on the node's machine          → "this machine can't be managed remotely"
+ *   - the node was not created by a daemon            → the Hub keeps no daemon for it
+ *   - the daemon that created it is offline
+ *   restart/edit (#570 — no daemon involved, the Hub pushes to the node itself):
+ *   - the node is not running                         → nothing would receive the doorbell
+ *   - it does not report config_update_capable        → no exit-75 supervisor: it would just die
+ *
+ * Pure functions here; the HTTP calls live in bin/cli.ts (nodeRemoteCommand).
+ */
+import type { PlannedCommand } from "./codex-menu";
+export type RemoteVerb = "start" | "stop" | "restart" | "edit";
+export declare const REMOTE_VERBS: readonly RemoteVerb[];
+export declare const DEFAULT_WAIT_SECONDS = 60;
+export declare const MAX_WAIT_SECONDS = 600;
+export type RemoteArgs = {
+    verb: RemoteVerb;
+    alias: string | null;
+    network: string | null;
+    model: string | null;
+    yes: boolean;
+    force: boolean;
+    waitSeconds: number;
+    error: string | null;
+};
+/** True when this `anet node <verb> …` invocation is the remote form. */
+export declare function isRemoteInvocation(argv: string[]): boolean;
+/**
+ * @param argv everything after `anet node <verb>` (the verb itself excluded).
+ * Unknown flags are refused: a local-only flag (`--tmux`, `--copresence`, `--runtime` …) silently
+ * ignored on a remote node would be a lie about what was done.
+ */
+export declare function parseRemoteArgs(verb: RemoteVerb, argv: string[]): RemoteArgs;
+export type HubNodeRow = {
+    node_id: string;
+    alias: string;
+    hostname?: string | null;
+    role?: string | null;
+    lifecycle_state?: string | null;
+    lifecycle_controllable?: boolean;
+    lifecycle_daemon_node_id?: string | null;
+    model?: string | null;
+};
+export type HubSession = {
+    alias?: string;
+    node_id?: string | null;
+    status?: string | null;
+    hostname?: string | null;
+    host?: {
+        hostname?: string | null;
+    } | null;
+    last_seen_at?: string | null;
+    updated_at?: string | null;
+    model?: string | null;
+};
+/** GET /api/host-supervisors row: the daemon's node id is `daemon_node_id` (not `node_id`). */
+export type HubDaemon = {
+    daemon_node_id?: string;
+    alias?: string;
+    hostname?: string | null;
+    online?: boolean;
+    last_seen_at?: string | null;
+};
+export type RemoteTarget = {
+    node_id: string;
+    alias: string;
+    hostname: string | null;
+    lifecycle_state: string;
+    session_status: string | null;
+    session_seen: string | null;
+    model: string | null;
+    /** The daemon that created the node (start/stop go through it). null = not daemon-managed: only
+     *  restart/edit resolve without one. `online` is false only for restart/edit (they don't need it). */
+    daemon: {
+        node_id: string;
+        alias: string;
+        online: boolean;
+    } | null;
+};
+export type ResolveResult = {
+    ok: true;
+    target: RemoteTarget;
+} | {
+    ok: false;
+    code: "not_found" | "is_daemon" | "daemons_not_visible" | "no_daemon_on_host" | "not_daemon_managed" | "creator_daemon_offline";
+    message: string;
+};
+/**
+ * @param nodes    GET /api/nodes?alias=<alias>&network_id=<net>  (rows; newest first)
+ * @param sessions GET /api/status?network_id=<net>                (sessions)
+ * @param daemons  GET /api/host-supervisors?network_id=<net>      (daemons; [] = none visible)
+ */
+export declare function resolveRemoteTarget(verb: RemoteVerb, alias: string, nodes: HubNodeRow[], sessions: HubSession[], daemons: HubDaemon[]): ResolveResult;
+export type Precheck = {
+    kind: "go";
+} | {
+    kind: "noop";
+    message: string;
+} | {
+    kind: "refuse";
+    message: string;
+};
+export declare function isRunning(t: RemoteTarget): boolean;
+export declare function precheck(verb: RemoteVerb, t: RemoteTarget, cfg?: {
+    config_update_capable?: boolean;
+} | null): Precheck;
+export declare function remoteCommandArgv(a: {
+    verb: RemoteVerb;
+    alias: string;
+    networkId: string;
+    model?: string | null;
+    force?: boolean;
+}): string[];
+export declare function describePlan(verb: RemoteVerb, t: RemoteTarget, model?: string | null): string;
+/** The one-line "where/what" header printed before the plan. */
+export declare function describeTarget(verb: RemoteVerb, t: RemoteTarget): string;
+export declare function planRemote(a: {
+    verb: RemoteVerb;
+    target: RemoteTarget;
+    networkId: string;
+    model?: string | null;
+    force?: boolean;
+}): PlannedCommand;
+export declare function toolCall(verb: RemoteVerb, t: RemoteTarget, networkId: string, opts?: {
+    model?: string | null;
+    force?: boolean;
+    baseRevision?: number;
+}): {
+    name: string;
+    arguments: Record<string, unknown>;
+};
+export declare function explainHubRefusal(verb: RemoteVerb, alias: string, r: any): string;
+export type Observation = {
+    lifecycle_state: string | null;
+    session_status: string | null;
+    session_seen: string | null;
+    config_revision: number | null;
+    model: string | null;
+};
+export type Outcome = {
+    state: "pending";
+} | {
+    state: "done";
+    message: string;
+} | {
+    state: "failed";
+    message: string;
+};
+/**
+ * @param before what the hub showed right before dispatch
+ * @param now    what it shows now
+ * Seen-times are compared as the hub's own strings (changed or not), never against this machine's
+ * clock: the node is on another machine and the hub on a third.
+ */
+export declare function evaluateOutcome(verb: RemoteVerb, t: RemoteTarget, before: Observation, now: Observation, want?: {
+    model?: string | null;
+    baseRevision?: number;
+}): Outcome;
+/**
+ * @param last the last observation before the deadline (null = none could be read). For restart/edit it
+ *             tells "went down and never came back" (the supervisor did not respawn it — a real failure
+ *             worth a different next step) apart from "still finishing its turn".
+ */
+export declare function timeoutMessage(verb: RemoteVerb, alias: string, seconds: number, last?: Observation | null, host?: string | null): string;

package/dist/src/node-running-guard.d.ts

@@ -0,0 +1,9 @@
+export declare const isAgentNodeCommand: (cmdline: string) => boolean;
+export interface RunningNodeProbe {
+    pidFileContent: string | null;
+    isAlive: (pid: number) => boolean;
+    commandOf: (pid: number) => string | null;
+}
+/** 返回还活着且确实是 agent-node 的 pid;否则 null(不存在 / 死了 / pid 被别的进程复用)。 */
+export declare const runningNodePid: (probe: RunningNodeProbe) => number | null;
+export declare const alreadyRunningMessage: (displayName: string, pid: number) => string[];

package/dist/src/node-server-identity.d.ts

@@ -0,0 +1,35 @@
+export interface NodeIdentityFromConfig {
+    node_id?: string;
+    node_name?: string;
+    model?: string;
+}
+export declare function nodeIdentityFromConfig(path: string | undefined): NodeIdentityFromConfig;
+export interface NodeRowLike {
+    node_id?: string | null;
+    alias?: string | null;
+    runtime?: string | null;
+    config_path?: string | null;
+}
+export type NodeIdClaimVerdict = {
+    claim: true;
+} | {
+    claim: false;
+    owner: string;
+    runtime: string | null;
+    config_path: string | null;
+};
+export declare function nodeIdClaimVerdict(nodeId: string, rows: readonly NodeRowLike[], alias: string): NodeIdClaimVerdict;
+export type NodeIdClaimState = "ok" | "conflict" | "unknown";
+/** 取 hub 上这个 node_id 的行并下结论;任何失败都是 "unknown"(调用方这次不报 node_id)。 */
+export declare function checkNodeIdClaim(opts: {
+    hubUrl: string;
+    token: string;
+    nodeId: string;
+    alias: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<{
+    state: NodeIdClaimState;
+    verdict?: NodeIdClaimVerdict;
+    error?: string;
+}>;

package/dist/src/node-server-payload.d.ts

@@ -0,0 +1,66 @@
+/**
+ * What gets written to `<project>/.anet/node-server.js` (issue #1216).
+ *
+ * The target name is not negotiable: `agent-node`'s grok co-presence spawn
+ * gate pins the CommHub MCP payload to exactly that path, so whatever the
+ * source is, the file that lands there is called `.js`.
+ *
+ * 🔴 The bug this module exists to remove: the old code copied the source
+ * verbatim and justified it with a comment claiming
+ *
+ *     "bun runs .ts content under a .js extension fine"
+ *
+ * which is false — bun selects its parser from the extension:
+ *
+ *     $ printf 'function f(x: string): void {}\nf("hi");\n' > probe.ts
+ *     $ cp probe.ts probe.js
+ *     $ bun probe.ts   → runs
+ *     $ bun probe.js   → error: Expected ")" but found ":"
+ *
+ * An installed npm package never hit it, because its first resolver candidate
+ * (`dist/src/node-server.js`) is compiled. Only a source checkout fell through
+ * to `src/node-server.ts` — i.e. every local run and every hand-verified PR.
+ *
+ * And the symptom was three layers from the cause: the node died on
+ * `grok copresence CommHub MCP readiness preflight failed (1)`, which names
+ * neither a file nor a parse error.
+ */
+/** Injected so the decision is testable without spawning anything. */
+export interface TypeScriptBundler {
+    /** Returns the self-contained JavaScript for `entryPath`, or throws. */
+    bundleSync(entryPath: string): string;
+}
+export declare class NodeServerPayloadError extends Error {
+    constructor(message: string);
+}
+/**
+ * Decide what bytes belong at the `.js` target for a given source path.
+ *
+ * A `.js` source is passed through untouched — the published package ships a
+ * compiled bundle there, and re-processing it risks changing bytes for no gain.
+ *
+ * 🔴 A `.ts` source must be **bundled, not merely transpiled**. Stripping types
+ * fixes the parse error but leaves the file's relative imports pointing at
+ * siblings that do not exist beside the destination:
+ *
+ *     import { inboundChannelMeta } from "./channel-meta.js";
+ *     → Cannot find module './channel-meta.js' from '<project>/.anet/node-server.js'
+ *
+ * That second failure is why transpiling alone still ended at
+ * "CommHub MCP readiness preflight failed (1)". The published
+ * `dist/src/node-server.js` works precisely because it is a self-contained
+ * bundle, so a source checkout has to produce the same shape.
+ */
+export declare function nodeServerPayloadFor(source: string, sourcePath: string, bundler: TypeScriptBundler | null): string;
+/**
+ * The bundler available on this runtime, or null.
+ *
+ * bun can bundle; the published CLI runs under node and cannot — but it also
+ * never resolves a `.ts` candidate (its `dist/` copy wins), so null there is
+ * correct rather than a gap.
+ *
+ * `spawnSync` rather than `Bun.build()` because both call sites are
+ * synchronous, and making them async would change the ordering of the file
+ * writes around them.
+ */
+export declare function ambientTypeScriptTranspiler(): TypeScriptBundler | null;

package/dist/src/node-server-rules-file.d.ts

@@ -0,0 +1,14 @@
+export declare const CLAUDE_CODE_RULES_RUNTIME = "claude";
+export interface RulesDoorbellDeps {
+    callCommHub: (method: string, params: Record<string, unknown>) => Promise<any>;
+    workDir: string;
+    log: (msg: string) => void;
+    /** 技能的用户级根目录(~/.claude/skills)取自这里;缺省 os.homedir()。测试注入临时目录。 */
+    home?: string;
+}
+/** SSE 事件分派:是 rules_file 门铃就处理并返回 true;其它事件原样返回 false。 */
+export declare function handleRulesFileEvent(event: {
+    type?: unknown;
+} | null | undefined, deps: RulesDoorbellDeps): Promise<boolean>;
+/** 连上 / 重连后补拉一次:断线期间桌面端可能已发起请求(hub 侧 60s 内仍 pending)。 */
+export declare function drainRulesFileRequests(deps: RulesDoorbellDeps, why: string): Promise<number>;

package/dist/src/node-server-version.d.ts

@@ -0,0 +1,39 @@
+export declare const NODE_SERVER_VERSION_MARKER_PREFIX = "// anet-node-server-version: ";
+/** The version carried by a node-server payload, or null if it has no valid marker. */
+export declare function readNodeServerVersion(text: string | null | undefined): string | null;
+/**
+ * Add the marker if the payload has none. A leading `#!` line stays first so
+ * the file is still directly executable.
+ */
+export declare function stampNodeServerVersion(payload: string, version: string): string;
+/**
+ * Version of the agent-network package that owns `sourcePath`, found by walking
+ * up (dist/src/node-server.js → package root is two levels up; src/node-server.ts
+ * one level). Null when no agent-network package.json is found.
+ */
+export declare function owningAgentNetworkVersion(sourcePath: string): string | null;
+/** Ensure the payload carries a marker, deriving the version from its source package when needed. */
+export declare function ensureNodeServerVersionMarker(payload: string, sourcePath: string): string;
+export type NodeServerWriteDecision = {
+    action: "write";
+    existingVersion: string | null;
+    incomingVersion: string | null;
+} | {
+    action: "keep-newer";
+    existingVersion: string;
+    incomingVersion: string;
+};
+/**
+ * Keep the existing file only when BOTH sides carry a valid marker and the
+ * existing one is strictly newer. Everything else behaves as before (#549).
+ */
+export declare function decideNodeServerWrite(existing: string | null, incoming: string): NodeServerWriteDecision;
+/** The one-line warning printed when a newer file is kept. */
+export declare function nodeServerKeptNewerWarning(existingVersion: string, incomingVersion: string): string;
+export type NodeServerApplyResult = "wrote" | "unchanged" | "kept-newer";
+/**
+ * The single write path both cli.ts writers use: stamp the payload, refuse to
+ * downgrade a newer existing file (warning once via `warn`), otherwise write
+ * when the bytes differ.
+ */
+export declare function applyNodeServerPayload(targetPath: string, payload: string, sourcePath: string, warn?: (line: string) => void): NodeServerApplyResult;