@reticlehq/server 2.12.0 → 2.13.0

package/dist/cli/daemon-start-options.js

@@ -0,0 +1,38 @@
+import { DAEMON_INNER_COMMAND, DRIVE_FLAG, HEADED_FLAG, HTTP_FLAG, HTTP_PORT_FLAG, HTTP_TOKEN_FLAG, PORT_FLAG, } from './cli-parse.js';
+export function daemonStartOptions(parsed) {
+    return {
+        port: parsed.port,
+        headless: parsed.headless,
+        ...(parsed.driveUrl !== undefined ? { driveUrl: parsed.driveUrl } : {}),
+        ...(parsed.http
+            ? {
+                httpVerify: true,
+                ...(parsed.httpPort !== undefined ? { httpVerifyPort: parsed.httpPort } : {}),
+                ...(parsed.httpToken !== undefined ? { httpVerifyToken: parsed.httpToken } : {}),
+            }
+            : {}),
+    };
+}
+/**
+ * The argv a parent hands its detached `_daemon` child.
+ *
+ * `serve` and `mcp` each built this list by hand and each made the SAME mistake as the options
+ * builder above — pushing `--headed` only inside the `driveUrl` branch — so the flag survived
+ * parsing, was dropped at the spawn, and the child launched a hidden pool. Three sites, one wrong
+ * idea: that headless belongs to the drive URL. It belongs to the pool, which exists either way.
+ */
+export function daemonSpawnArgs(parsed) {
+    const args = [DAEMON_INNER_COMMAND, PORT_FLAG, String(parsed.port)];
+    if (parsed.driveUrl !== undefined)
+        args.push(DRIVE_FLAG, parsed.driveUrl);
+    if (!parsed.headless)
+        args.push(HEADED_FLAG);
+    if (parsed.http) {
+        args.push(HTTP_FLAG);
+        if (parsed.httpPort !== undefined)
+            args.push(HTTP_PORT_FLAG, String(parsed.httpPort));
+        if (parsed.httpToken !== undefined)
+            args.push(HTTP_TOKEN_FLAG, parsed.httpToken);
+    }
+    return args;
+}

package/dist/cli/device-flow.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The browser device flow's wire shapes and its hand-off to a real browser.
+ *
+ * `reticle login` works like `gh auth login`: the CLI asks the cloud for a device code, opens the
+ * approval page, and polls until a human confirms it in a session that is already signed in. That
+ * confirmation is the whole security of the flow — only somebody already authenticated in the
+ * dashboard can turn a device code into a token for their org.
+ *
+ * Split from `cloud-cli` because it is self-contained: the schemas describe two endpoints and the
+ * opener knows only about platforms. Nothing here reads a session, a credential, or a project.
+ */
+import { z } from 'zod';
+/** What `/v1/auth/device/start` answers: the codes, where to approve, and how fast to poll. */
+export declare const DeviceStartSchema: z.ZodObject<{
+    deviceCode: z.ZodString;
+    userCode: z.ZodString;
+    verificationUri: z.ZodString;
+    verificationUriComplete: z.ZodString;
+    interval: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete: string;
+    interval: number;
+    expiresAt: number;
+}, {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete: string;
+    interval: number;
+    expiresAt: number;
+}>;
+/**
+ * What `/v1/auth/device/token` answers while polling. Everything past `status` is optional because
+ * only an APPROVED poll carries a token, and `org.id` is absent on a cloud older than org-scoped
+ * credentials.
+ */
+export declare const DevicePollSchema: z.ZodObject<{
+    status: z.ZodString;
+    token: z.ZodOptional<z.ZodString>;
+    org: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id?: string | undefined;
+    }, {
+        name: string;
+        id?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    org?: {
+        name: string;
+        id?: string | undefined;
+    } | undefined;
+    token?: string | undefined;
+}, {
+    status: string;
+    org?: {
+        name: string;
+        id?: string | undefined;
+    } | undefined;
+    token?: string | undefined;
+}>;
+/**
+ * Best-effort open the approval page in the default browser.
+ *
+ * Every failure is swallowed on purpose: the URL is printed either way, and a headless box, a
+ * container, or an SSH session has no opener at all. Refusing to log in because a convenience did
+ * not work would break the one environment that most needs the printed fallback.
+ */
+export declare const openBrowser: (target: string) => void;

package/dist/cli/device-flow.js

@@ -0,0 +1,56 @@
+/**
+ * The browser device flow's wire shapes and its hand-off to a real browser.
+ *
+ * `reticle login` works like `gh auth login`: the CLI asks the cloud for a device code, opens the
+ * approval page, and polls until a human confirms it in a session that is already signed in. That
+ * confirmation is the whole security of the flow — only somebody already authenticated in the
+ * dashboard can turn a device code into a token for their org.
+ *
+ * Split from `cloud-cli` because it is self-contained: the schemas describe two endpoints and the
+ * opener knows only about platforms. Nothing here reads a session, a credential, or a project.
+ */
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+import { NodePlatform } from '../platform.js';
+/** What `/v1/auth/device/start` answers: the codes, where to approve, and how fast to poll. */
+export const DeviceStartSchema = z.object({
+    deviceCode: z.string(),
+    userCode: z.string(),
+    verificationUri: z.string(),
+    verificationUriComplete: z.string(),
+    interval: z.number(),
+    expiresAt: z.number(),
+});
+/**
+ * What `/v1/auth/device/token` answers while polling. Everything past `status` is optional because
+ * only an APPROVED poll carries a token, and `org.id` is absent on a cloud older than org-scoped
+ * credentials.
+ */
+export const DevicePollSchema = z.object({
+    status: z.string(),
+    token: z.string().optional(),
+    org: z.object({ id: z.string().optional(), name: z.string() }).optional(),
+});
+/**
+ * Best-effort open the approval page in the default browser.
+ *
+ * Every failure is swallowed on purpose: the URL is printed either way, and a headless box, a
+ * container, or an SSH session has no opener at all. Refusing to log in because a convenience did
+ * not work would break the one environment that most needs the printed fallback.
+ */
+export const openBrowser = (target) => {
+    const cmd = NodePlatform.MACOS === process.platform
+        ? 'open'
+        : NodePlatform.WINDOWS === process.platform
+            ? 'cmd'
+            : 'xdg-open';
+    const args = NodePlatform.WINDOWS === process.platform ? ['/c', 'start', '', target] : [target];
+    try {
+        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => undefined);
+        child.unref();
+    }
+    catch {
+        /* no opener available — the user opens the printed URL manually */
+    }
+};

package/dist/cli/doctor-rows.d.ts

@@ -31,6 +31,15 @@ export declare const DoctorRow: {
     readonly DAEMON: "daemon";
     readonly VERSION: "version";
     readonly SESSIONS: "sessions";
+    /**
+     * The agent-to-daemon hop, which every other row here is blind to.
+     *
+     * Reported from the field: a user with the SDK injected, the overlay visible, a live session on
+     * the daemon and every tool listed in their client was still told by three separate agents that
+     * Reticle was not present. Their words: "four green checkmarks that don't add up to a working
+     * verification." Every row in this list checks a COMPONENT; none checked a LINK.
+     */
+    readonly AGENT_LINK: "agent link";
     readonly BRIDGE_PORT: "bridge port";
     readonly PORT_CHECK: "port check";
     readonly SIBLING: "sibling";

package/dist/cli/doctor-rows.js

@@ -31,6 +31,15 @@ export const DoctorRow = {
     DAEMON: 'daemon',
     VERSION: 'version',
     SESSIONS: 'sessions',
+    /**
+     * The agent-to-daemon hop, which every other row here is blind to.
+     *
+     * Reported from the field: a user with the SDK injected, the overlay visible, a live session on
+     * the daemon and every tool listed in their client was still told by three separate agents that
+     * Reticle was not present. Their words: "four green checkmarks that don't add up to a working
+     * verification." Every row in this list checks a COMPONENT; none checked a LINK.
+     */
+    AGENT_LINK: 'agent link',
     BRIDGE_PORT: 'bridge port',
     PORT_CHECK: 'port check',
     SIBLING: 'sibling',

package/dist/cli/drive-attach.d.ts

@@ -78,6 +78,19 @@ export declare function readAttachResponse(port: number, url: string, res: {
 export declare function requestDriveSession(port: number, url: string, post?: DrivePost): Promise<DriveAttachResult>;
 /** The success line. Names the session, because that is the handle everything downstream needs. */
 export declare function describeAttached(port: number, url: string, session: DriveSession): string;
+/**
+ * What an attach cannot honour: the window.
+ *
+ * `drive` documents a HEADED browser and parses `--headless` as the opt-out, but the attach path
+ * POSTs a url and nothing else — the daemon answers from a pool it launched headless at boot, and no
+ * per-request flag can change a browser that is already running. So the run is invisible, which is
+ * the half of the field report that reads "the app starts to run headlessly".
+ *
+ * Saying so is the honest half. The other half is that the run is no longer unwatchable: the HUD
+ * feed is mirrored to every other tab of the same app (see Session.setViewers), so a tab the human
+ * already has open shows the narration and the counters as the leased context is driven.
+ */
+export declare function driveHeadlessOnAttach(port: number, url: string): string;
 /**
  * A stranger holds the port, in words `drive` can honour.
  *

package/dist/cli/drive-attach.js

@@ -147,6 +147,24 @@ export function describeAttached(port, url, session) {
     return (`attached to the Reticle daemon on :${String(port)} — it is driving ${url} as session ` +
         `${session.sessionId}, which every Reticle tool can address.${life}`);
 }
+/**
+ * What an attach cannot honour: the window.
+ *
+ * `drive` documents a HEADED browser and parses `--headless` as the opt-out, but the attach path
+ * POSTs a url and nothing else — the daemon answers from a pool it launched headless at boot, and no
+ * per-request flag can change a browser that is already running. So the run is invisible, which is
+ * the half of the field report that reads "the app starts to run headlessly".
+ *
+ * Saying so is the honest half. The other half is that the run is no longer unwatchable: the HUD
+ * feed is mirrored to every other tab of the same app (see Session.setViewers), so a tab the human
+ * already has open shows the narration and the counters as the leased context is driven.
+ */
+export function driveHeadlessOnAttach(port, url) {
+    return (`note: this session runs inside the daemon on :${String(port)}, whose browser was launched ` +
+        'headless — there is no window to show, and `--headless` is not a per-drive choice. Open ' +
+        `${url} in your own browser to watch: any tab of that app mirrors this session's HUD. To get a ` +
+        'window instead, stop the daemon and run `reticle drive` again with the port free.');
+}
 /**
  * A stranger holds the port, in words `drive` can honour.
  *

package/dist/cli/drive-command.js

@@ -13,7 +13,7 @@ import { probeDaemon } from '../mcp/mcp-proxy.js';
 import { readPid } from '../daemon/daemon.js';
 import { fetchStatus } from './cli-launch.js';
 import { captureLookup, findPortHolder } from './port-holder.js';
-import { DriveMode, decideDriveMode, describeAttached, driveForeignHolder, driveRaceLost, requestDriveSession, } from './drive-attach.js';
+import { DriveMode, decideDriveMode, describeAttached, driveForeignHolder, driveHeadlessOnAttach, driveRaceLost, requestDriveSession, } from './drive-attach.js';
 export function handleDrive(parsed) {
     void driveWithHonestConflict(parsed);
 }
@@ -43,7 +43,7 @@ async function driveWithHonestConflict(parsed) {
         return;
     }
     if (DriveMode.ATTACH === mode) {
-        await attachToRunningDaemon(parsed.port, parsed.driveUrl);
+        await attachToRunningDaemon(parsed.port, parsed.driveUrl, parsed.headless);
         return;
     }
     // The probe cannot close the race: something can take the port between here and the bind, and the
@@ -81,7 +81,7 @@ async function driveWithHonestConflict(parsed) {
  * against it renews its lease), and a foreground hold here could only keep it alive by faking tool
  * calls at it.
  */
-async function attachToRunningDaemon(port, url) {
+async function attachToRunningDaemon(port, url, headless) {
     const result = await requestDriveSession(port, url);
     if (!result.ok) {
         log('reticle_drive_attach_failed', { port, url, reason: result.reason });
@@ -96,6 +96,10 @@ async function attachToRunningDaemon(port, url) {
         ready: result.session.ready,
     });
     process.stderr.write(`${describeAttached(port, url, result.session)}\n`);
+    // The command's own default is headed, and this path cannot deliver that. Said out loud rather
+    // than left for the user to discover by watching a window that never opens.
+    if (!headless)
+        process.stderr.write(`${driveHeadlessOnAttach(port, url)}\n`);
     // A tab that never connected is not a drive session, and reporting one is the false green this
     // command exists to avoid.
     if (!result.session.ready)

package/dist/cli/mcp-command.js

@@ -13,10 +13,16 @@ import { PortPresence, probePresence, presenceIsUsable, describePresence, } from
 import { waitForDaemon, startMcpProxy, probeDaemon, proxyLog, setProxyLogPort, } from '../mcp/mcp-proxy.js';
 import { installProxyResilience } from '../daemon/daemon-resilience.js';
 import { readProjectId } from './cli-port.js';
-import { DAEMON_INNER_COMMAND, PORT_FLAG, DRIVE_FLAG, HEADED_FLAG, HTTP_FLAG, HTTP_PORT_FLAG, HTTP_TOKEN_FLAG, } from './cli-parse.js';
-import { resolveMcpPort } from '../daemon/daemon-resolve.js';
+import { resolveMcpPort, daemonProjectAt } from '../daemon/daemon-resolve.js';
+import { daemonSpawnArgs } from './daemon-start-options.js';
+import { WakeAction, decideWake } from '../daemon/wake-decision.js';
 import { pickDaemonPortToBind } from '../daemon/free-port.js';
 import { fetchStatus } from './cli-launch.js';
+import { migrateApprovals } from '../setup/approval-migration.js';
+import { ReticleEnv } from '@reticlehq/core';
+import { agentIo } from '../setup/agent-io.js';
+import { SERVER_VERSION } from '../version/server-version.js';
+import { homedir } from 'node:os';
 /**
  * MCP proxy mode: ensures the daemon is running, then bridges Claude Code's
  * stdin/stdout to the daemon's SSE endpoint. This is the recommended way to
@@ -36,7 +42,25 @@ export async function handleMcp(opts) {
     // proxy's transport built around a single fixed number. Making the proxy chase a moving port would
     // mean reworking the reconnect path, which is the one piece whose failure reads to a user as
     // "the MCP server disappeared mid-session".
-    const port = await resolveMcpPort(opts.port, readProjectId(process.cwd()), reticleStateHome(), {
+    // Read once and reused by the wake path below: the boot resolution and every later wake must be
+    // defending the SAME identity, and computing it twice is how they drift apart.
+    // Before the port work, because it is the only moment we are guaranteed to get on a machine that
+    // installed Reticle before the pre-approval rules existed. Once per version, never a create that
+    // supersedes an allowlist we cannot read, and it cannot throw: see approval-migration.
+    // A sandboxed state dir means a test, a gate or a fixture, none of which are asking us to rewrite
+    // the real user's editor configuration.
+    if (undefined === process.env[ReticleEnv.STATE_DIR]) {
+        migrateApprovals({
+            io: agentIo,
+            home: homedir(),
+            platform: process.platform,
+            stateHome: reticleStateHome(),
+            version: SERVER_VERSION,
+            log,
+        });
+    }
+    const projectId = readProjectId(process.cwd());
+    const port = await resolveMcpPort(opts.port, projectId, reticleStateHome(), {
         alive: isAlive,
         daemonPresent: async (p) => presenceIsUsable(await probePresence(p, { tcpOpen: probeDaemon, status: fetchStatus })),
         pickPort: (p) => pickDaemonPortToBind(p),
@@ -71,29 +95,36 @@ export async function handleMcp(opts) {
         // client request woke into the identical non-answer. Rejecting here is what puts the proxy
         // dormant with a reason, instead of pretending the wake succeeded.
         const presence = await probePresence(port, { tcpOpen: probeDaemon, status: fetchStatus });
-        if (presenceIsUsable(presence))
+        // Identity, not just presence. `resolveMcpPort` above already refuses to adopt a stranger's
+        // daemon at boot; this is the same question asked on every WAKE, which is where it was missing.
+        //
+        // Reachable by ordinary use, with no error anywhere: a daemon retires on its idle timer and
+        // frees the port, another project's daemon binds it, and this project's dormant proxy wakes
+        // straight onto it. The agent then drives, asserts and reports a verdict about a DIFFERENT
+        // APPLICATION. That is worse than the disconnect it was reintroduced under the cover of, because
+        // a disconnect is visible and this is a false green wearing a valid session.
+        const wake = decideWake(presence, daemonProjectAt(port, reticleStateHome()), projectId);
+        if (WakeAction.USE === wake)
             return;
-        if (PortPresence.FREE !== presence)
-            throw new Error(describePresence(presence, port));
+        if (WakeAction.REFUSE === wake) {
+            throw new Error(PortPresence.DAEMON === presence
+                ? `the daemon on port ${String(port)} belongs to a different project, so this one will ` +
+                    'not adopt it. Stop it, or start this project on its own port.'
+                : describePresence(presence, port));
+        }
         const scriptPath = process.argv[1];
         if (scriptPath === undefined) {
             log('reticle_mcp_no_script', {});
             process.exit(1);
         }
-        const daemonArgs = [DAEMON_INNER_COMMAND, PORT_FLAG, String(port)];
-        if (driveUrl !== undefined) {
-            daemonArgs.push(DRIVE_FLAG, driveUrl);
-            if (!headless)
-                daemonArgs.push(HEADED_FLAG);
-        }
-        // Forward the HTTP-verify flags too (previously silently dropped for `reticle mcp`).
-        if (http) {
-            daemonArgs.push(HTTP_FLAG);
-            if (httpPort !== undefined)
-                daemonArgs.push(HTTP_PORT_FLAG, String(httpPort));
-            if (httpToken !== undefined)
-                daemonArgs.push(HTTP_TOKEN_FLAG, httpToken);
-        }
+        const daemonArgs = daemonSpawnArgs({
+            port,
+            headless,
+            http,
+            ...(driveUrl !== undefined ? { driveUrl } : {}),
+            ...(httpPort !== undefined ? { httpPort } : {}),
+            ...(httpToken !== undefined ? { httpToken } : {}),
+        });
         spawnDaemon(process.execPath, scriptPath, daemonArgs, port);
         // Announce the daemon only once the PORT ACCEPTS. This line used to be written the instant the
         // child was spawned, which on a Windows first bootstrap meant `reticle_mcp_daemon_started`

package/dist/cli/project-name.d.ts

@@ -0,0 +1,30 @@
+/**
+ * What project a repo binds to when nobody says.
+ *
+ * `link` used to answer "default" for every repo on every machine, which is wrong in two directions
+ * at once. Measured: two unrelated checkouts linked on one account — a storefront and a billing
+ * service — both bound to a single project called "Default" and shared one key, so their runs,
+ * issues and impact merged into one bucket and the dashboard's per-project view described nothing.
+ * It is also what made two TENANTS collide, because a credential slot built from a project id is
+ * only as distinct as the ids are.
+ *
+ * A repo already knows its name: the directory it lives in. That is not a guess, it is the name its
+ * owner chose and the one they will look for in a project list.
+ */
+/** The id used when a directory name yields nothing usable — the historical behaviour, unchanged. */
+export declare const DEFAULT_PROJECT_ID = "default";
+/**
+ * Turn a directory name into a project id: lowercase, and anything that is not a letter or digit
+ * becomes a single hyphen. Conservative on purpose — this id ends up in URLs, in credential slot
+ * keys and in a project list somebody has to read.
+ */
+export declare const slugifyProjectName: (raw: string) => string;
+/**
+ * The project a `link` with no `--project` should target.
+ *
+ * The EXISTING binding wins over the directory name, and that ordering is the whole safety of this
+ * change. A repo that is already linked has history in a project; re-running `link` — which people
+ * do to rotate a key or repoint an environment — must land in that same project or the history
+ * silently splits in two, which is worse than the shared-bucket problem this fixes.
+ */
+export declare const defaultProjectFor: (cwdBasename: string, existingProjectId: string | undefined) => string;

package/dist/cli/project-name.js

@@ -0,0 +1,44 @@
+/**
+ * What project a repo binds to when nobody says.
+ *
+ * `link` used to answer "default" for every repo on every machine, which is wrong in two directions
+ * at once. Measured: two unrelated checkouts linked on one account — a storefront and a billing
+ * service — both bound to a single project called "Default" and shared one key, so their runs,
+ * issues and impact merged into one bucket and the dashboard's per-project view described nothing.
+ * It is also what made two TENANTS collide, because a credential slot built from a project id is
+ * only as distinct as the ids are.
+ *
+ * A repo already knows its name: the directory it lives in. That is not a guess, it is the name its
+ * owner chose and the one they will look for in a project list.
+ */
+/** Cap the slug so a deep or oddly-named checkout cannot produce an unreadable project id. */
+const MAX_SLUG = 48;
+/** The id used when a directory name yields nothing usable — the historical behaviour, unchanged. */
+export const DEFAULT_PROJECT_ID = 'default';
+/**
+ * Turn a directory name into a project id: lowercase, and anything that is not a letter or digit
+ * becomes a single hyphen. Conservative on purpose — this id ends up in URLs, in credential slot
+ * keys and in a project list somebody has to read.
+ */
+export const slugifyProjectName = (raw) => {
+    const slug = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, MAX_SLUG)
+        .replace(/-+$/g, '');
+    return 0 === slug.length ? DEFAULT_PROJECT_ID : slug;
+};
+/**
+ * The project a `link` with no `--project` should target.
+ *
+ * The EXISTING binding wins over the directory name, and that ordering is the whole safety of this
+ * change. A repo that is already linked has history in a project; re-running `link` — which people
+ * do to rotate a key or repoint an environment — must land in that same project or the history
+ * silently splits in two, which is worse than the shared-bucket problem this fixes.
+ */
+export const defaultProjectFor = (cwdBasename, existingProjectId) => {
+    if (existingProjectId !== undefined && existingProjectId.length > 0)
+        return existingProjectId;
+    return slugifyProjectName(cwdBasename);
+};

package/dist/cli/status-next-action.d.ts

@@ -27,6 +27,20 @@ export interface StatusFacts {
      * paths do the first without the second.
      */
     initialized: boolean;
+    /**
+     * Ports of dev servers that ANNOUNCED themselves — i.e. that have Reticle loaded in the process
+     * actually running.
+     *
+     * `nextActionFor` already ranks on a listening-port list; it just never had one from here, so this
+     * command passed `[]` and every wired project with a live dev server was told "the app is probably
+     * not running". That is advice contradicting the terminal the reader is looking at, and it sends
+     * them to restart something already up.
+     *
+     * Stronger than the port scan the field was designed for: a scanned port proves something is
+     * listening, an announced one proves it is listening AND instrumented. Optional so every existing
+     * caller keeps today's behaviour.
+     */
+    devServerPorts?: readonly number[];
 }
 /**
  * What to do next, or `undefined` when a session is connected and there is nothing to fix.

package/dist/cli/status-next-action.js

@@ -43,9 +43,9 @@ export function statusNextAction(facts) {
             `Reticle tool, and it exits again when idle. ${wiring} Ask your agent to verify something, then ` +
             `run status again.`).replace(/\s+/g, ' ');
     }
-    // The daemon is up and no page has connected. `nextActionFor` owns the ranking; the CLI cannot see
-    // listening ports or a dev command from here, so it passes what it has and lets that function say
-    // what is missing rather than guessing at it.
+    // The daemon is up and no page has connected. `nextActionFor` owns the ranking; this passes what
+    // it has and lets that function say what is missing rather than guessing at it. It CAN see
+    // listening ports now — the announced ones — which is what the empty list here used to cost.
     const next = nextActionFor({
         // The durable bit IS this side's `everConnected`. In-process the flag means "this daemon has served
         // a session", which a daemon seconds old cannot know; from the CLI the honest equivalent is "an app
@@ -53,7 +53,7 @@ export function statusNextAction(facts) {
         // is in question at all.
         everConnected: facts.previouslyConnected,
         initialized: facts.initialized,
-        listening: [],
+        listening: facts.devServerPorts ?? [],
         dev: undefined,
         previouslyConnected: facts.previouslyConnected,
     });

package/dist/cli.d.ts

@@ -2,3 +2,4 @@
 import { parseCliArgs, CLI_USAGE } from './cli/cli-parse.js';
 export { parseCliArgs, CLI_USAGE };
 export type { CliResult } from './cli/cli-parse.js';
+export declare function handleStatus(port: number): Promise<void>;