@cjhyy/code-shell-server 0.8.0

package/dist/mobile-remote/trusted-device-store.d.ts

@@ -0,0 +1,19 @@
+import type { TrustedDevicePublic } from "./types.js";
+export declare class TrustedDeviceStore {
+    private readonly filePath;
+    constructor(filePath: string);
+    addDevice(input: {
+        name: string;
+        secretHash: string;
+    }): TrustedDevicePublic;
+    listDevices(): TrustedDevicePublic[];
+    authenticate(id: string, secretHash: string): TrustedDevicePublic | undefined;
+    revoke(id: string): boolean;
+    /** Hard-delete a device row entirely (no revoked zombie left behind). */
+    remove(id: string): boolean;
+    /** Rename a device's display label. Rejects blank names and unknown ids. */
+    rename(id: string, name: string): boolean;
+    private readAll;
+    private writeAll;
+    private toPublic;
+}

package/dist/mobile-remote/trusted-device-store.js

@@ -0,0 +1,118 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { randomUUID, timingSafeEqual } from "node:crypto";
+/**
+ * Constant-time compare for a device's bearer credential (secretHash), so
+ * authentication doesn't leak hash bytes through compare-timing (Y-3).
+ * `timingSafeEqual` requires equal-length buffers and throws otherwise — a
+ * length mismatch is itself a non-match, so we short-circuit to false. The
+ * length check isn't constant-time, but it only reveals the (fixed, public)
+ * length of a correct hash, not its content.
+ */
+function secretHashEquals(a, b) {
+    const bufA = Buffer.from(a, "utf-8");
+    const bufB = Buffer.from(b, "utf-8");
+    if (bufA.length !== bufB.length)
+        return false;
+    return timingSafeEqual(bufA, bufB);
+}
+export class TrustedDeviceStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    addDevice(input) {
+        const devices = this.readAll();
+        // Get-or-create by secretHash. A phone's secret is stable per browser
+        // (persisted in localStorage as cs.deviceSecret), so re-scanning the QR
+        // code — which the client always prefers over re-auth when the URL carries
+        // a fresh pairing token — used to mint a BRAND-NEW device every time, piling
+        // up trusted devices unboundedly. Reuse the existing row instead, refreshing
+        // its name + lastSeenAt. (mobile-remote device accumulation)
+        const existing = devices.find((d) => d.secretHash === input.secretHash && !d.revokedAt);
+        if (existing) {
+            existing.name = input.name;
+            existing.lastSeenAt = Date.now();
+            this.writeAll(devices);
+            return this.toPublic(existing);
+        }
+        const device = {
+            id: randomUUID(),
+            name: input.name,
+            secretHash: input.secretHash,
+            createdAt: Date.now(),
+        };
+        devices.push(device);
+        this.writeAll(devices);
+        return this.toPublic(device);
+    }
+    listDevices() {
+        return this.readAll().map((device) => this.toPublic(device));
+    }
+    authenticate(id, secretHash) {
+        const devices = this.readAll();
+        const device = devices.find((item) => item.id === id && !item.revokedAt && secretHashEquals(item.secretHash, secretHash));
+        if (!device)
+            return undefined;
+        device.lastSeenAt = Date.now();
+        this.writeAll(devices);
+        return this.toPublic(device);
+    }
+    revoke(id) {
+        const devices = this.readAll();
+        const device = devices.find((item) => item.id === id && !item.revokedAt);
+        if (!device)
+            return false;
+        device.revokedAt = Date.now();
+        this.writeAll(devices);
+        return true;
+    }
+    /** Hard-delete a device row entirely (no revoked zombie left behind). */
+    remove(id) {
+        const devices = this.readAll();
+        const next = devices.filter((item) => item.id !== id);
+        if (next.length === devices.length)
+            return false;
+        this.writeAll(next);
+        return true;
+    }
+    /** Rename a device's display label. Rejects blank names and unknown ids. */
+    rename(id, name) {
+        const trimmed = name.trim();
+        if (!trimmed)
+            return false;
+        const devices = this.readAll();
+        const device = devices.find((item) => item.id === id);
+        if (!device)
+            return false;
+        device.name = trimmed;
+        this.writeAll(devices);
+        return true;
+    }
+    readAll() {
+        if (!existsSync(this.filePath))
+            return [];
+        return JSON.parse(readFileSync(this.filePath, "utf-8"));
+    }
+    writeAll(devices) {
+        mkdirSync(dirname(this.filePath), { recursive: true });
+        // 0o600: devices.json holds each device's secretHash (its bearer credential).
+        // Owner-only, same hardening as settings.json/credentials.json/cookie leases.
+        // (Y-3 partial: this closes the world-readable file; the non-timing-safe `===`
+        // compare stays in the §2.4 mobile-remote-hardening bucket for the user.)
+        writeFileSync(this.filePath, JSON.stringify(devices, null, 2), { encoding: "utf-8", mode: 0o600 });
+        try {
+            chmodSync(this.filePath, 0o600);
+        }
+        catch { /* best-effort: tighten an existing file */ }
+    }
+    toPublic(device) {
+        return {
+            id: device.id,
+            name: device.name,
+            createdAt: device.createdAt,
+            lastSeenAt: device.lastSeenAt,
+            revokedAt: device.revokedAt,
+        };
+    }
+}

package/dist/mobile-remote/tunnel-manager.d.ts

@@ -0,0 +1,105 @@
+import { type ChildProcess } from "node:child_process";
+import { EventEmitter } from "node:events";
+export type TunnelStatus = "connected" | "disconnected" | "error";
+export type SpawnFn = (command: string, args: string[]) => ChildProcess;
+/** Probe cloudflared's local metrics `/ready` endpoint; true once the edge
+ *  connection count is > 0. Default implementation fetches over loopback. */
+export type CheckReadyFn = (metricsPort: number) => Promise<boolean>;
+export interface TunnelManagerOptions {
+    /** Path to the cloudflared binary (from CloudflaredBinary.binaryPath()). */
+    binaryPath: () => string;
+    /** Injectable spawn for tests. */
+    spawn?: SpawnFn;
+    /** How long to wait for the tunnel URL before failing. Default 15s. */
+    timeoutMs?: number;
+    /** Local metrics port cloudflared exposes (we poll its /ready). */
+    metricsPort?: number;
+    /** Injectable readiness probe for tests. */
+    checkReady?: CheckReadyFn;
+    /** How long to wait for the edge connection to become ready. Default 20s. */
+    readyTimeoutMs?: number;
+    /** Poll interval while waiting for readiness. Default 500ms. */
+    readyIntervalMs?: number;
+    /** Poll interval after connect; set <= 0 to disable runtime health checks. */
+    healthCheckIntervalMs?: number;
+    /** Consecutive failed readiness probes before reporting a disconnect. */
+    healthFailureThreshold?: number;
+    /** Grace after SIGTERM before escalating to SIGKILL when tearing a child down. */
+    killGraceMs?: number;
+    /** Absolute cap on waiting for a killed child to exit (SIGKILL already sent). */
+    killHardTimeoutMs?: number;
+}
+/**
+ * Owns the cloudflared *process* only. `start` spawns a temporary tunnel and
+ * resolves once the `https://*.trycloudflare.com` URL appears on stdout/stderr;
+ * if no URL arrives within the timeout it kills the child and rejects. After a
+ * successful start, an unsolicited child exit (crash) emits a `disconnected`
+ * status — we deliberately do NOT auto-restart (spec decision: a silent
+ * address change without a refreshed QR is worse than a visible disconnect).
+ * `stop()` kills the child and suppresses the disconnected event.
+ */
+export declare class TunnelManager extends EventEmitter {
+    private readonly getBinaryPath;
+    private readonly spawn;
+    private readonly timeoutMs;
+    private readonly metricsPort;
+    private readonly checkReady;
+    private readonly readyTimeoutMs;
+    private readonly readyIntervalMs;
+    private readonly healthCheckIntervalMs;
+    private readonly healthFailureThreshold;
+    private readonly killGraceMs;
+    private readonly killHardTimeoutMs;
+    private child?;
+    /** In-flight teardown of a previous child. Any start() awaits this first so a
+     *  new cloudflared never spawns while the old one still owns the metrics port. */
+    private pendingTeardown?;
+    private stopping;
+    private connected;
+    private currentUrl?;
+    private healthTimer?;
+    private healthCheckInFlight;
+    private healthGeneration;
+    private consecutiveHealthFailures;
+    constructor(opts: TunnelManagerOptions);
+    start(port: number): Promise<{
+        url: string;
+    }>;
+    /**
+     * Poll cloudflared's /ready until the edge connection is up, or reject after
+     * `readyTimeoutMs`. This is what distinguishes a working tunnel from one that
+     * registered a connection but can't actually serve traffic (error 1033).
+     */
+    private waitForReady;
+    private startHealthMonitor;
+    private stopHealthMonitor;
+    private pollHealth;
+    /**
+     * Tear the current child down and remember the wait as `pendingTeardown` so a
+     * subsequent start() blocks until the process has really exited (freeing the
+     * metrics port). Shared by stop(), startup-failure, and restart so there is a
+     * single teardown path — the missing shared wait was the stop()→start() race.
+     * Idempotent: with no live child it resolves immediately.
+     */
+    private beginTeardown;
+    /**
+     * SIGTERM the child, and if it hasn't exited within `killGraceMs`, escalate to
+     * SIGKILL — cloudflared's SIGTERM is a graceful drain (default ~30s) that
+     * would otherwise keep the metrics port bound long past a re-open. Normally
+     * resolves on the process's real `exit`; `killHardTimeoutMs` is a last-resort
+     * cap so a child that never reports exit can't hang teardown forever. That cap
+     * is reached only AFTER SIGKILL was already sent, so on macOS/Linux the port is
+     * in practice released by then — it is a safety valve, not the happy path.
+     */
+    private killAndWait;
+    /**
+     * Kill the cloudflared child and suppress the disconnect event. Returns a
+     * promise that resolves once the process has actually exited so callers that
+     * immediately restart don't race the port. Fire-and-forget callers may ignore
+     * it (kept sync-compatible: existing `tunnelManager.stop()` sites work).
+     */
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    isConnected(): boolean;
+    publicUrl(): string | undefined;
+}

package/dist/mobile-remote/tunnel-manager.js

@@ -0,0 +1,375 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+const TRYCLOUDFLARE_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+const DEFAULT_TIMEOUT_MS = 15_000;
+const DEFAULT_READY_TIMEOUT_MS = 20_000;
+const DEFAULT_READY_INTERVAL_MS = 500;
+const DEFAULT_METRICS_PORT = 20741;
+const DEFAULT_HEALTH_CHECK_INTERVAL_MS = 5_000;
+const DEFAULT_HEALTH_FAILURE_THRESHOLD = 3;
+// cloudflared handles SIGTERM but does NOT exit promptly (graceful drain,
+// default ~30s per cloudflared docs). Give it a short grace, then SIGKILL so
+// the fixed metrics port is released before we re-spawn — otherwise the new
+// process can't bind 127.0.0.1:20741 and exits code=1.
+const DEFAULT_KILL_GRACE_MS = 2_000;
+const DEFAULT_KILL_HARD_TIMEOUT_MS = 3_000;
+async function defaultCheckReady(metricsPort) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${metricsPort}/ready`, {
+            signal: AbortSignal.timeout(2_000),
+        });
+        if (!res.ok)
+            return false;
+        const body = (await res.json());
+        return (body.readyConnections ?? 0) > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Owns the cloudflared *process* only. `start` spawns a temporary tunnel and
+ * resolves once the `https://*.trycloudflare.com` URL appears on stdout/stderr;
+ * if no URL arrives within the timeout it kills the child and rejects. After a
+ * successful start, an unsolicited child exit (crash) emits a `disconnected`
+ * status — we deliberately do NOT auto-restart (spec decision: a silent
+ * address change without a refreshed QR is worse than a visible disconnect).
+ * `stop()` kills the child and suppresses the disconnected event.
+ */
+export class TunnelManager extends EventEmitter {
+    getBinaryPath;
+    spawn;
+    timeoutMs;
+    metricsPort;
+    checkReady;
+    readyTimeoutMs;
+    readyIntervalMs;
+    healthCheckIntervalMs;
+    healthFailureThreshold;
+    killGraceMs;
+    killHardTimeoutMs;
+    child;
+    /** In-flight teardown of a previous child. Any start() awaits this first so a
+     *  new cloudflared never spawns while the old one still owns the metrics port. */
+    pendingTeardown;
+    stopping = false;
+    connected = false;
+    currentUrl;
+    healthTimer;
+    healthCheckInFlight = false;
+    healthGeneration = 0;
+    consecutiveHealthFailures = 0;
+    constructor(opts) {
+        super();
+        this.getBinaryPath = opts.binaryPath;
+        this.spawn = opts.spawn ?? nodeSpawn;
+        this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.metricsPort = opts.metricsPort ?? DEFAULT_METRICS_PORT;
+        this.checkReady = opts.checkReady ?? defaultCheckReady;
+        this.readyTimeoutMs = opts.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+        this.readyIntervalMs = opts.readyIntervalMs ?? DEFAULT_READY_INTERVAL_MS;
+        this.healthCheckIntervalMs = opts.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS;
+        this.healthFailureThreshold = Math.max(1, opts.healthFailureThreshold ?? DEFAULT_HEALTH_FAILURE_THRESHOLD);
+        this.killGraceMs = opts.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
+        this.killHardTimeoutMs = opts.killHardTimeoutMs ?? DEFAULT_KILL_HARD_TIMEOUT_MS;
+    }
+    async start(port) {
+        // A previous cloudflared may still be around: a *soft* disconnect (edge
+        // /ready lost) deliberately keeps the child alive so it can auto-recover,
+        // so `this.child` can be set here even though the UI shows "disconnected".
+        // Blindly throwing "隧道已在运行" (or spawning immediately) is exactly the
+        // bug that forced a full app restart: the old process still holds the fixed
+        // metrics port, so the fresh cloudflared can't bind it and exits code=1.
+        // Tear the stale child down and WAIT for it to actually exit (freeing the
+        // port) before starting fresh, so re-opening always works.
+        // Tear down a still-live child (soft disconnect keeps it alive) AND await
+        // any teardown already in flight from a prior stop()/failure — the old
+        // cloudflared must fully exit and release 127.0.0.1:20741 before we spawn,
+        // or the new one fails to bind and exits code=1 (the app-restart bug).
+        if (this.child) {
+            await this.beginTeardown();
+        }
+        else if (this.pendingTeardown) {
+            await this.pendingTeardown;
+        }
+        this.stopping = false;
+        this.connected = false;
+        this.currentUrl = undefined;
+        this.stopHealthMonitor();
+        const child = this.spawn(this.getBinaryPath(), [
+            "tunnel",
+            "--no-autoupdate",
+            // Force http2 (TCP). cloudflared defaults to QUIC (UDP/7844), which is
+            // blocked on many networks (corp Wi-Fi, some carriers) — the connection
+            // object registers but never becomes ready, so the phone hits Cloudflare
+            // error 1033. http2 falls back to TCP/443 and reliably connects.
+            "--protocol",
+            "http2",
+            // Fixed local metrics endpoint so we can poll /ready for edge readiness.
+            "--metrics",
+            `127.0.0.1:${this.metricsPort}`,
+            "--url",
+            `http://127.0.0.1:${port}`,
+        ]);
+        this.child = child;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finishReject = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                // Route through the shared teardown so a retried start() awaits this
+                // child's real exit (releasing the metrics port) before re-spawning.
+                void this.beginTeardown();
+                reject(err);
+            };
+            const timer = setTimeout(() => {
+                finishReject(new Error("隧道启动失败:15s 内未取得公网地址(超时)"));
+            }, this.timeoutMs);
+            const scan = (buf) => {
+                if (settled)
+                    return;
+                const match = TRYCLOUDFLARE_RE.exec(String(buf));
+                if (!match)
+                    return;
+                // URL captured, but the edge connection is NOT necessarily ready yet —
+                // resolving here was the 1033 bug (handing back a dead QR). Stop the
+                // URL scanners and wait for /ready before declaring connected.
+                child.stdout?.off("data", scan);
+                child.stderr?.off("data", scan);
+                clearTimeout(timer);
+                const url = match[0];
+                this.waitForReady()
+                    .then(() => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    this.connected = true;
+                    this.currentUrl = url;
+                    this.emit("status", "connected", url);
+                    this.startHealthMonitor();
+                    resolve({ url });
+                })
+                    .catch((err) => finishReject(err));
+            };
+            child.stdout?.on("data", scan);
+            child.stderr?.on("data", scan);
+            child.on("error", (err) => {
+                // A superseded child (torn down by a restart / stop-during-start) must
+                // NOT touch shared state — killAndWait owns its lifecycle. Match the exit
+                // guard exactly: identity alone, regardless of whether this child's start
+                // promise ever settled (stop() can supersede an unsettled child).
+                if (this.child !== child)
+                    return;
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    this.child = undefined;
+                    this.connected = false;
+                    this.currentUrl = undefined;
+                    this.stopHealthMonitor();
+                    this.emit("status", "error", err);
+                    reject(err);
+                }
+                else if (!this.stopping) {
+                    this.emit("status", "error", err);
+                }
+            });
+            child.on("exit", (code, signal) => {
+                // A superseded child (torn down by stop()/restart) exiting must NOT
+                // clear this.child / connected / health — those now belong to the new
+                // tunnel. killAndWait already awaits this exit; ignore it here.
+                if (this.child !== child)
+                    return;
+                const wasConnected = this.connected;
+                this.child = undefined;
+                this.connected = false;
+                this.currentUrl = undefined;
+                this.stopHealthMonitor();
+                if (this.stopping)
+                    return;
+                if (wasConnected) {
+                    this.emit("status", "disconnected", { code, signal });
+                }
+                else if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    reject(new Error(`cloudflared 退出(code=${code ?? "?"} signal=${signal ?? "?"})`));
+                }
+            });
+        });
+    }
+    /**
+     * Poll cloudflared's /ready until the edge connection is up, or reject after
+     * `readyTimeoutMs`. This is what distinguishes a working tunnel from one that
+     * registered a connection but can't actually serve traffic (error 1033).
+     */
+    async waitForReady() {
+        const deadline = Date.now() + this.readyTimeoutMs;
+        for (;;) {
+            if (this.child && (await this.checkReady(this.metricsPort)))
+                return;
+            if (Date.now() >= deadline) {
+                throw new Error("隧道注册失败:公网边缘连接未就绪(可能网络限制,扫码会报 1033)");
+            }
+            await new Promise((r) => setTimeout(r, this.readyIntervalMs));
+        }
+    }
+    startHealthMonitor() {
+        this.stopHealthMonitor();
+        if (this.healthCheckIntervalMs <= 0)
+            return;
+        this.consecutiveHealthFailures = 0;
+        const generation = ++this.healthGeneration;
+        const timer = setInterval(() => {
+            void this.pollHealth(generation);
+        }, this.healthCheckIntervalMs);
+        timer.unref?.();
+        this.healthTimer = timer;
+    }
+    stopHealthMonitor() {
+        if (this.healthTimer)
+            clearInterval(this.healthTimer);
+        this.healthTimer = undefined;
+        this.healthGeneration += 1;
+        this.healthCheckInFlight = false;
+        this.consecutiveHealthFailures = 0;
+    }
+    async pollHealth(generation) {
+        if (generation !== this.healthGeneration ||
+            this.healthCheckInFlight ||
+            !this.child ||
+            this.stopping) {
+            return;
+        }
+        this.healthCheckInFlight = true;
+        try {
+            const ready = await this.checkReady(this.metricsPort);
+            if (generation !== this.healthGeneration || !this.child || this.stopping)
+                return;
+            if (ready) {
+                this.consecutiveHealthFailures = 0;
+                if (!this.connected) {
+                    this.connected = true;
+                    this.emit("status", "connected", this.currentUrl);
+                }
+                return;
+            }
+            this.consecutiveHealthFailures += 1;
+            if (this.connected && this.consecutiveHealthFailures >= this.healthFailureThreshold) {
+                this.connected = false;
+                this.emit("status", "disconnected", {
+                    reason: "ready-check-failed",
+                    consecutiveFailures: this.consecutiveHealthFailures,
+                });
+            }
+        }
+        catch (err) {
+            if (generation !== this.healthGeneration || !this.child || this.stopping)
+                return;
+            this.emit("status", "error", err);
+        }
+        finally {
+            if (generation === this.healthGeneration) {
+                this.healthCheckInFlight = false;
+            }
+        }
+    }
+    /**
+     * Tear the current child down and remember the wait as `pendingTeardown` so a
+     * subsequent start() blocks until the process has really exited (freeing the
+     * metrics port). Shared by stop(), startup-failure, and restart so there is a
+     * single teardown path — the missing shared wait was the stop()→start() race.
+     * Idempotent: with no live child it resolves immediately.
+     */
+    beginTeardown() {
+        this.stopping = true;
+        this.connected = false;
+        this.currentUrl = undefined;
+        this.stopHealthMonitor();
+        const child = this.child;
+        this.child = undefined;
+        if (!child) {
+            // No live child, but a PRIOR teardown may still be draining (e.g.
+            // finishReject() started one, then a stop() re-enters here). Do NOT clear
+            // it — a retried start() must still await that exit before spawning, or it
+            // races the held metrics port. Return the in-flight wait (or resolved).
+            return this.pendingTeardown ?? Promise.resolve();
+        }
+        const wait = this.killAndWait(child).finally(() => {
+            // Only clear if no newer teardown superseded this one.
+            if (this.pendingTeardown === wait)
+                this.pendingTeardown = undefined;
+        });
+        this.pendingTeardown = wait;
+        return wait;
+    }
+    /**
+     * SIGTERM the child, and if it hasn't exited within `killGraceMs`, escalate to
+     * SIGKILL — cloudflared's SIGTERM is a graceful drain (default ~30s) that
+     * would otherwise keep the metrics port bound long past a re-open. Normally
+     * resolves on the process's real `exit`; `killHardTimeoutMs` is a last-resort
+     * cap so a child that never reports exit can't hang teardown forever. That cap
+     * is reached only AFTER SIGKILL was already sent, so on macOS/Linux the port is
+     * in practice released by then — it is a safety valve, not the happy path.
+     */
+    killAndWait(child) {
+        return new Promise((resolve) => {
+            let done = false;
+            // Declared before finish() so a synchronous exit (fake/edge case) or a
+            // throwing kill() can clear them without hitting the temporal dead zone.
+            let graceTimer;
+            let hardTimer;
+            const finish = () => {
+                if (done)
+                    return;
+                done = true;
+                if (graceTimer)
+                    clearTimeout(graceTimer);
+                if (hardTimer)
+                    clearTimeout(hardTimer);
+                resolve();
+            };
+            child.once("exit", finish);
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+                finish();
+                return;
+            }
+            if (done)
+                return; // exit fired synchronously during kill()
+            graceTimer = setTimeout(() => {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    /* already gone */
+                }
+            }, this.killGraceMs);
+            hardTimer = setTimeout(finish, this.killHardTimeoutMs);
+            graceTimer.unref?.();
+            hardTimer.unref?.();
+        });
+    }
+    /**
+     * Kill the cloudflared child and suppress the disconnect event. Returns a
+     * promise that resolves once the process has actually exited so callers that
+     * immediately restart don't race the port. Fire-and-forget callers may ignore
+     * it (kept sync-compatible: existing `tunnelManager.stop()` sites work).
+     */
+    stop() {
+        return this.beginTeardown();
+    }
+    isRunning() {
+        return Boolean(this.child);
+    }
+    isConnected() {
+        return this.connected;
+    }
+    publicUrl() {
+        return this.currentUrl;
+    }
+}

package/dist/mobile-remote/types.d.ts

@@ -0,0 +1 @@
+export type { TrustedDevice, TrustedDevicePublic, PairingToken, ApprovalScope, ApprovalPathScope, MobileRemotePermissionMode as PermissionMode, CcDiscoveredSession, CcHistoryMessage, CcApprovalDecision, MobilePermissionModeSnapshotEntry, MobileProjectMeta, MobileImageMime, MobileImageBase, MobileImageAttachment, MobileAttachmentSummary, MobileClientEvent, MobileServerEvent, RoomPublic, MobileSessionMeta, } from "@cjhyy/code-shell-core";

package/dist/mobile-remote/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mobile-remote/viewer-identity.d.ts

@@ -0,0 +1,5 @@
+export interface MobileViewerIdentity {
+    deviceId: string;
+    viewerId: string;
+}
+export declare function mobileTranscriptSubscriberId(viewerId: string): string;

package/dist/mobile-remote/viewer-identity.js

@@ -0,0 +1,5 @@
+export function mobileTranscriptSubscriberId(viewerId) {
+    if (!viewerId)
+        throw new Error("authenticated mobile viewer id required");
+    return `mobile:${viewerId}`;
+}

package/dist/serve/cli.d.ts

@@ -0,0 +1,15 @@
+interface CliArgs {
+    cwd: string;
+    host: string;
+    port: number;
+    passcode?: string;
+    dataDir: string;
+    staticRootDir?: string;
+}
+export declare function parseServeArgs(argv: string[], env?: NodeJS.ProcessEnv): CliArgs;
+/** Locate the stdio worker entry the same way desktop's AgentBridge does. */
+export declare function resolveWorkerEntry(): string;
+/** Locate the built browser app (packages/web `app` build), when present. */
+export declare function resolveWebAppRoot(): string | undefined;
+export declare function runServeCli(argv?: string[]): Promise<void>;
+export {};