@xfey/tenso 0.1.134 → 0.1.135

package/dist/server-shell/cli/args.d.ts

@@ -25,6 +25,8 @@ export type CliCommand = {
     yes: boolean;
 } | {
     kind: "internal-console-run";
+} | {
+    kind: "internal-desktop-runtime";
 } | {
     kind: "internal-desktop-open";
     url?: string;

package/dist/server-shell/cli/args.js

@@ -149,11 +149,13 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
                     : "internal-package-update-complete",
             };
         }
-        if (internalCommand === "console-run") {
+        if (internalCommand === "console-run" || internalCommand === "desktop-runtime") {
             if (args.length > 0) {
                 throw new LaunchError("git_bootstrap_failed", "Internal console-run does not accept options", "Internal commands are managed by Tenso.");
             }
-            return { kind: "internal-console-run" };
+            return {
+                kind: internalCommand === "console-run" ? "internal-console-run" : "internal-desktop-runtime",
+            };
         }
         if (internalCommand === "desktop-open") {
             if (args.length > 1) {

package/dist/server-shell/cli/cli.js

@@ -14,6 +14,8 @@ import { resolveRelayUrl } from "./launch.js";
 import { ensureLocalConsole, openLocalConsoleBrowser, readLocalConsoleServiceStatus, restartLocalConsoleService, runLocalConsoleProcess, stopLocalConsoleService, } from "../local-console/index.js";
 import { runPackageUpdateCompletionProtocol, runPackageUpdateWorkerProtocol, } from "../local-console/package-update-process.js";
 import { recoverPackageUpdateForConsoleStartup } from "../local-console/package-update-recovery.js";
+import { runDesktopRuntimeBridge } from "../desktop-runtime/bridge.js";
+import { openInstalledMacApplication } from "../desktop-runtime/installation.js";
 const HELP_TEXT = `Usage:
   tenso
   tenso launch [target] [--yes] [--foreground]
@@ -235,6 +237,10 @@ async function ensureUserLocalConsole(options) {
     return (await ensureLocalConsole({ cwd: options.cwd, env, source: options.source })).url;
 }
 async function runLocalConsoleCommand() {
+    if (openInstalledMacApplication()) {
+        process.stdout.write("Opened Tenso for Mac.\n");
+        return;
+    }
     const url = await ensureUserLocalConsole({ cwd: process.cwd(), source: "terminal" });
     if (openLocalConsoleBrowser(url)) {
         process.stdout.write(`Tenso is ready at ${new URL(url).origin}/console\n`);
@@ -407,6 +413,9 @@ try {
         case "internal-console-run":
             await runLocalConsoleProcess();
             break;
+        case "internal-desktop-runtime":
+            await runDesktopRuntimeBridge();
+            break;
         case "internal-desktop-open":
             await runDesktopOpenCommand(command.url);
             break;

package/dist/server-shell/desktop-integration/manager.js

@@ -1,4 +1,5 @@
 import { homedir } from "node:os";
+import { installedMacApplication } from "../desktop-runtime/installation.js";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveTuttiHome } from "../../providers/openai/index.js";
@@ -139,6 +140,9 @@ function createRealContext(options) {
     const cwd = resolve(options.cwd ?? process.cwd());
     const env = options.env ?? process.env;
     const platform = options.platform ?? process.platform;
+    const nativeApplication = platform === "darwin" ? installedMacApplication(env) : null;
+    if (nativeApplication !== null)
+        return { status: "installed", entry_path: nativeApplication, changed: false };
     const runner = options.runner ?? runDesktopCommand;
     const packageIdentity = readCliPackageIdentity();
     const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);

package/dist/server-shell/desktop-runtime/bridge.d.ts

@@ -0,0 +1,2 @@
+export declare function runDesktopRuntimeBridge(): Promise<void>;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/server-shell/desktop-runtime/bridge.js

@@ -0,0 +1,101 @@
+import { createInterface } from "node:readline";
+import { dirname, resolve } from "node:path";
+import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { ensureLocalConsole, readLocalConsoleServiceStatus, } from "../local-console/managed-console.js";
+import { readLocalConsoleRuntimeEndpoint, } from "../local-console/runtime-endpoint.js";
+import { executeDesktopOpenIntent, parseTuttiDesktopUrl } from "../desktop-integration/index.js";
+import { resolveRelayUrl } from "../cli/launch.js";
+import { parseDesktopRequest } from "./protocol.js";
+import { retireOwnedNpmLauncher } from "./installation.js";
+async function control(endpoint, path, body) {
+    const response = await fetch(`${endpoint.base_url}/local-console/v1/control/${path}`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${endpoint.control_token}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body ?? {}),
+        signal: AbortSignal.timeout(300_000),
+    });
+    if (!response.ok)
+        throw new Error(response.status === 404 ? "previous_installation_running" : "service_unavailable");
+    return (await response.json());
+}
+export async function runDesktopRuntimeBridge() {
+    const cwd = dirname(resolve(process.argv[1]));
+    const tuttiHome = resolveTuttiHome(process.env.TUTTI_HOME, cwd);
+    let booted = false;
+    let consoleInstance;
+    let inputBytes = 0;
+    process.stdin.on("data", (chunk) => {
+        inputBytes += chunk.length;
+        if (inputBytes > 64 * 1024)
+            process.exit(1);
+    });
+    const input = createInterface({ input: process.stdin, crlfDelay: Infinity });
+    for await (const line of input) {
+        inputBytes = 0;
+        let id = 0;
+        try {
+            const request = parseDesktopRequest(line);
+            id = request.id;
+            const intent = request.action === "protocol" ? parseTuttiDesktopUrl(request.url) : undefined;
+            let openUrl;
+            let result = { status: "ready" };
+            const current = readLocalConsoleRuntimeEndpoint(tuttiHome);
+            if (request.action === "quit" && current === null)
+                result = { status: "stopped" };
+            else if (request.action === "status" && current === null)
+                result = { status: "blocked", reason: "recovery_required" };
+            else if (request.action === "quit" || request.action === "status") {
+                result = await control(current, "desktop-session", {
+                    action: request.action === "quit" ? "exit" : "status",
+                });
+            }
+            else {
+                if (!booted && current !== null) {
+                    const status = await readLocalConsoleServiceStatus({ cwd });
+                    if (status.status === "running" && status.update_required) {
+                        const stopped = await control(current, "idle-shutdown");
+                        if (stopped.status === "blocked") {
+                            process.stdout.write(JSON.stringify({ id, ...stopped }) + "\n");
+                            continue;
+                        }
+                    }
+                }
+                const access = await ensureLocalConsole({ cwd, source: "desktop" });
+                if (!booted || consoleInstance !== access.endpoint.instance_id) {
+                    result = await control(access.endpoint, "desktop-session", { action: "restore" });
+                    booted = result.status === "ready";
+                    consoleInstance = booted ? access.endpoint.instance_id : undefined;
+                    if (booted)
+                        retireOwnedNpmLauncher(tuttiHome);
+                }
+                if (result.status === "ready") {
+                    if (request.action === "protocol") {
+                        await executeDesktopOpenIntent({
+                            intent: intent,
+                            accessUrl: access.url,
+                            relayUrl: resolveRelayUrl(process.env),
+                            openBrowser: (url) => {
+                                openUrl = url;
+                                return true;
+                            },
+                        });
+                    }
+                    else
+                        openUrl = access.url;
+                }
+            }
+            process.stdout.write(JSON.stringify({ id, ...result, ...(openUrl ? { open_url: openUrl } : {}) }) + "\n");
+        }
+        catch (error) {
+            const reason = error instanceof Error &&
+                ["invalid_request", "previous_installation_running"].includes(error.message)
+                ? error.message
+                : "service_unavailable";
+            process.stdout.write(JSON.stringify({ id, status: "error", reason }) + "\n");
+        }
+    }
+}
+//# sourceMappingURL=bridge.js.map

package/dist/server-shell/desktop-runtime/installation.d.ts

@@ -0,0 +1,4 @@
+export declare function installedMacApplication(env?: NodeJS.ProcessEnv): string | null;
+export declare function openInstalledMacApplication(): boolean;
+export declare function retireOwnedNpmLauncher(tuttiHome: string): void;
+//# sourceMappingURL=installation.d.ts.map

package/dist/server-shell/desktop-runtime/installation.js

@@ -0,0 +1,61 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { readCliPackageIdentity } from "../cli/version.js";
+import { createMacosDesktopAdapter } from "../desktop-integration/macos.js";
+import { readDesktopIntegrationRecord, writeDesktopIntegrationRecord, } from "../desktop-integration/record.js";
+export function installedMacApplication(env = process.env) {
+    if (process.platform !== "darwin" ||
+        (env.TUTTI_HOME !== undefined && resolve(env.TUTTI_HOME) !== join(homedir(), ".tutti")))
+        return null;
+    for (const app of ["/Applications/Tenso.app", join(homedir(), "Applications/Tenso.app")]) {
+        try {
+            const distribution = JSON.parse(readFileSync(join(app, "Contents/Resources/desktop-distribution.json"), "utf8"));
+            if (distribution.schema_version === 1 &&
+                typeof distribution.version === "string" &&
+                existsSync(join(app, "Contents/MacOS/Tenso")))
+                return app;
+        }
+        catch {
+            /* An npm-generated launcher or an unrelated app is not a distribution. */
+        }
+    }
+    return null;
+}
+export function openInstalledMacApplication() {
+    const app = installedMacApplication();
+    if (app === null)
+        return false;
+    return spawnSync("/usr/bin/open", ["-a", app], { stdio: "ignore", shell: false }).status === 0;
+}
+export function retireOwnedNpmLauncher(tuttiHome) {
+    const app = installedMacApplication();
+    if (app === null || resolve(tuttiHome) !== join(homedir(), ".tutti"))
+        return;
+    const current = readCliPackageIdentity();
+    if (current.root !== join(app, "Contents/Resources/host"))
+        return;
+    try {
+        const adapter = createMacosDesktopAdapter({
+            homeDir: homedir(),
+            assetRoot: join(current.root, "desktop-assets"),
+        });
+        const record = readDesktopIntegrationRecord(tuttiHome);
+        if (record?.state !== "installed" ||
+            record.entry_path !== adapter.entryPath ||
+            adapter.entryPath === app ||
+            adapter.inspect() !== "owned")
+            return;
+        adapter.remove();
+        writeDesktopIntegrationRecord(tuttiHome, {
+            ...record,
+            state: "removed",
+            updated_at: new Date().toISOString(),
+        });
+    }
+    catch {
+        /* Unknown or damaged ownership records are never removed. */
+    }
+}
+//# sourceMappingURL=installation.js.map

package/dist/server-shell/desktop-runtime/protocol.d.ts

@@ -0,0 +1,10 @@
+export type DesktopRequest = {
+    id: number;
+    action: "boot" | "open" | "status" | "quit";
+} | {
+    id: number;
+    action: "protocol";
+    url: string;
+};
+export declare function parseDesktopRequest(line: string): DesktopRequest;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/server-shell/desktop-runtime/protocol.js

@@ -0,0 +1,22 @@
+export function parseDesktopRequest(line) {
+    if (Buffer.byteLength(line) > 8192)
+        throw new Error("invalid_request");
+    const value = JSON.parse(line);
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error("invalid_request");
+    const v = value;
+    if (!Number.isSafeInteger(v.id) || v.id < 1)
+        throw new Error("invalid_request");
+    if (v.action === "protocol" &&
+        typeof v.url === "string" &&
+        v.url.length < 4096 &&
+        Object.keys(v).sort().join() === "action,id,url") {
+        return v;
+    }
+    if (["boot", "open", "status", "quit"].includes(v.action) &&
+        Object.keys(v).sort().join() === "action,id") {
+        return v;
+    }
+    throw new Error("invalid_request");
+}
+//# sourceMappingURL=protocol.js.map

package/dist/server-shell/desktop-runtime/session.d.ts

@@ -0,0 +1,32 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import type { LocalConsoleOperationCoordinator } from "../local-console/operation-coordinator.js";
+import { type PackageUpdateHostReadiness } from "../local-console/package-update-service.js";
+import { restorePackageUpdateHosts, stopPackageUpdateHost } from "../local-console/package-update-hosts.js";
+import { type PackageUpdateLockAcquisition } from "../local-console/package-update-lock.js";
+export type DesktopResult = {
+    status: "ready" | "blocked" | "stopped";
+    reason?: "host_busy" | "host_identity_unverified" | "console_busy" | "update_in_progress" | "recovery_required";
+    running_projects?: number;
+    restore_failed?: number;
+};
+export declare function readDesktopRestoreSet(tuttiHome: string): ProjectId[];
+export declare function writeDesktopRestoreSet(tuttiHome: string, ids: readonly ProjectId[]): void;
+type DesktopSessionOptions = {
+    tuttiHome: string;
+    env: NodeJS.ProcessEnv;
+    operations: LocalConsoleOperationCoordinator;
+    inspect?: () => Promise<PackageUpdateHostReadiness>;
+    stop?: typeof stopPackageUpdateHost;
+    restore?: typeof restorePackageUpdateHosts;
+    acquireLock?: () => PackageUpdateLockAcquisition;
+};
+export declare class DesktopSessionService {
+    #private;
+    constructor(options: DesktopSessionOptions);
+    status(): Promise<DesktopResult>;
+    restore(): Promise<DesktopResult>;
+    prepareExit(): Promise<DesktopResult>;
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=session.d.ts.map

package/dist/server-shell/desktop-runtime/session.js

@@ -0,0 +1,187 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { inspectMachineProjects } from "../cli/machine-project-inspector.js";
+import { readHostLocalPackageUpdateReadiness } from "../cli/local-control-client.js";
+import { inspectPackageUpdateHosts, } from "../local-console/package-update-service.js";
+import { restorePackageUpdateHosts, stopPackageUpdateHost, } from "../local-console/package-update-hosts.js";
+import { tryAcquirePackageUpdateLock, recoverDesktopPackageUpdateLock, } from "../local-console/package-update-lock.js";
+export function readDesktopRestoreSet(tuttiHome) {
+    const path = join(tuttiHome, "desktop", "session.json");
+    if (!existsSync(path))
+        return [];
+    const value = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error("desktop_record_invalid");
+    const record = value;
+    if (record.schema_version !== 1 ||
+        Object.keys(record).sort().join() !== "restore_project_ids,schema_version" ||
+        !Array.isArray(record.restore_project_ids) ||
+        record.restore_project_ids.length > 10000 ||
+        !record.restore_project_ids.every((id) => typeof id === "string" && /^prj_[0-9A-HJKMNP-TV-Z]{26}$/u.test(id))) {
+        throw new Error("desktop_record_invalid");
+    }
+    return [...new Set(record.restore_project_ids)];
+}
+export function writeDesktopRestoreSet(tuttiHome, ids) {
+    const path = join(tuttiHome, "desktop", "session.json");
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    chmodSync(dirname(path), 0o700);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, JSON.stringify({ schema_version: 1, restore_project_ids: [...new Set(ids)] }) + "\n", { mode: 0o600, flag: "wx" });
+        renameSync(temporary, path);
+    }
+    finally {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
+}
+export class DesktopSessionService {
+    #options;
+    #release;
+    #stopped = false;
+    constructor(options) {
+        this.#options = options;
+    }
+    async #inspect() {
+        if (this.#options.inspect)
+            return this.#options.inspect();
+        return inspectPackageUpdateHosts({
+            projects: await inspectMachineProjects({ tuttiHome: this.#options.tuttiHome }),
+            readReadiness: async (project) => project.endpoint.kind === "valid"
+                ? readHostLocalPackageUpdateReadiness({ endpoint: project.endpoint.record })
+                : "unsupported",
+        });
+    }
+    async status() {
+        if (this.#stopped)
+            return { status: "stopped" };
+        if (this.#options.operations.state() !== "idle")
+            return { status: "blocked", reason: "console_busy" };
+        const result = await this.#inspect();
+        return result.status === "ready"
+            ? { status: "ready", running_projects: result.restore_project_ids.length }
+            : { status: "blocked", reason: result.reason_code };
+    }
+    #acquire() {
+        const operation = this.#options.operations.tryBeginPackageUpdate();
+        if (!operation)
+            return { status: "blocked", reason: "console_busy" };
+        let lock;
+        try {
+            recoverDesktopPackageUpdateLock(this.#options.tuttiHome);
+            lock =
+                this.#options.acquireLock?.() ??
+                    tryAcquirePackageUpdateLock({ tuttiHome: this.#options.tuttiHome, purpose: "desktop" });
+        }
+        catch {
+            operation.release();
+            return { status: "blocked", reason: "recovery_required" };
+        }
+        if (lock.status !== "acquired") {
+            operation.release();
+            return {
+                status: "blocked",
+                reason: lock.status === "active" ? "update_in_progress" : "recovery_required",
+            };
+        }
+        this.#release = () => {
+            lock.lease.release();
+            operation.release();
+        };
+        return null;
+    }
+    async restore() {
+        const blocked = this.#acquire();
+        if (blocked)
+            return blocked;
+        try {
+            const ids = readDesktopRestoreSet(this.#options.tuttiHome);
+            const result = await this.#restore(ids);
+            writeDesktopRestoreSet(this.#options.tuttiHome, result.failed_project_ids);
+            return { status: "ready", restore_failed: result.failed_project_ids.length };
+        }
+        finally {
+            this.dispose();
+        }
+    }
+    #restore(projectIds) {
+        return (this.#options.restore ?? restorePackageUpdateHosts)({
+            tuttiHome: this.#options.tuttiHome,
+            projectIds,
+            env: this.#options.env,
+        });
+    }
+    async prepareExit() {
+        if (this.#stopped)
+            return { status: "stopped" };
+        const blocked = this.#acquire();
+        if (blocked)
+            return blocked;
+        const stopped = [];
+        let previous;
+        let recoveryWritten = false;
+        try {
+            const readiness = await this.#inspect();
+            if (readiness.status === "blocked")
+                return { status: "blocked", reason: readiness.reason_code };
+            try {
+                previous = readDesktopRestoreSet(this.#options.tuttiHome);
+            }
+            catch {
+                return { status: "blocked", reason: "recovery_required" };
+            }
+            // Persist before stopping the first Host, so a crash can restore partial progress.
+            writeDesktopRestoreSet(this.#options.tuttiHome, [
+                ...previous,
+                ...readiness.restore_project_ids,
+            ]);
+            recoveryWritten = true;
+            for (const projectId of readiness.restore_project_ids) {
+                const result = await (this.#options.stop ?? stopPackageUpdateHost)({
+                    tuttiHome: this.#options.tuttiHome,
+                    projectId,
+                });
+                if (result !== "stopped") {
+                    // A rejected response may follow an accepted shutdown whose response was lost.
+                    // Reconcile the attempted Host as well; restore skips verified running Hosts.
+                    const restored = await this.#restore([...stopped, projectId]);
+                    writeDesktopRestoreSet(this.#options.tuttiHome, [
+                        ...previous,
+                        ...restored.failed_project_ids,
+                    ]);
+                    return {
+                        status: "blocked",
+                        reason: result,
+                        restore_failed: restored.failed_project_ids.length,
+                    };
+                }
+                stopped.push(projectId);
+            }
+            this.#stopped = true;
+            // Hold both leases until Console closes, preventing a new Launch during quit/update.
+            return { status: "stopped" };
+        }
+        catch {
+            if (!recoveryWritten)
+                return { status: "blocked", reason: "recovery_required" };
+            const restored = await this.#restore(readDesktopRestoreSet(this.#options.tuttiHome));
+            writeDesktopRestoreSet(this.#options.tuttiHome, restored.failed_project_ids);
+            return {
+                status: "blocked",
+                reason: "recovery_required",
+                restore_failed: restored.failed_project_ids.length,
+            };
+        }
+        finally {
+            if (!this.#stopped)
+                this.dispose();
+        }
+    }
+    dispose() {
+        this.#release?.();
+        this.#release = undefined;
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/server-shell/local-console/package-update-lock.d.ts

@@ -29,6 +29,7 @@ export declare function tryAcquirePackageUpdateLock(options: {
     pid?: number;
     staleMs?: number;
     processAlive?: (pid: number) => boolean;
+    purpose?: "desktop";
 }): PackageUpdateLockAcquisition;
 export declare function removeRecoverablePackageUpdateLock(options: {
     tuttiHome: string;
@@ -36,6 +37,8 @@ export declare function removeRecoverablePackageUpdateLock(options: {
     staleMs?: number;
     processAlive?: (pid: number) => boolean;
 }): boolean;
+/** Only native lifecycle locks with a proven dead owner; never a pending npm update. */
+export declare function recoverDesktopPackageUpdateLock(tuttiHome: string): void;
 export declare function transferPackageUpdateLockFromCurrentProcess(options: {
     tuttiHome: string;
     nextPid: number;

package/dist/server-shell/local-console/package-update-lock.js

@@ -92,7 +92,7 @@ export function tryAcquirePackageUpdateLock(options) {
     const path = packageUpdateLockPath(options.tuttiHome);
     const now = options.now ?? Date.now;
     ensurePrivateRuntimeDirectory(path);
-    const ownerId = randomBytes(16).toString("base64url");
+    const ownerId = `${options.purpose === "desktop" ? "desktop-" : ""}${randomBytes(16).toString("base64url")}`;
     const timestamp = new Date(now()).toISOString();
     const record = {
         schema_version: 1,
@@ -176,6 +176,21 @@ export function removeRecoverablePackageUpdateLock(options) {
         return false;
     }
 }
+/** Only native lifecycle locks with a proven dead owner; never a pending npm update. */
+export function recoverDesktopPackageUpdateLock(tuttiHome) {
+    const path = packageUpdateLockPath(tuttiHome);
+    const record = parseRecord(path);
+    if (!record?.owner_id.startsWith("desktop-") || defaultProcessAlive(record.pid))
+        return;
+    if (parseRecord(path)?.owner_id !== record.owner_id)
+        return;
+    try {
+        unlinkSync(path);
+    }
+    catch {
+        /* Another lifecycle process may have recovered it. */
+    }
+}
 export function transferPackageUpdateLockFromCurrentProcess(options) {
     if (!isPositiveInteger(options.nextPid)) {
         return false;

package/dist/server-shell/local-console/server.js

@@ -1,5 +1,6 @@
 import { createProjectFolder, defaultProjectsDirectory, } from "./project-folders.js";
 import { timingSafeEqual } from "node:crypto";
+import { DesktopSessionService } from "../desktop-runtime/session.js";
 import { registerConsoleBrowserBridge } from "./browser-bridge.js";
 import { LocalConsoleManagedProjectService } from "./managed-project-service.js";
 import { registerLocalConsoleManagedProjectRoutes } from "./managed-project-routes.js";
@@ -81,6 +82,17 @@ export function createLocalConsoleServer(options) {
         ...(options.now === undefined ? {} : { now: options.now }),
     });
     const operations = options.operationCoordinator ?? new LocalConsoleOperationCoordinator();
+    const desktopSession = new DesktopSessionService({
+        tuttiHome,
+        operations,
+        env: options.env ?? process.env,
+    });
+    let nativeShutdownLease;
+    app.addHook("onClose", (_instance, done) => {
+        desktopSession.dispose();
+        nativeShutdownLease?.release();
+        done();
+    });
     const projects = new LocalConsoleProjectService({
         tuttiHome,
         operations,
@@ -232,6 +244,37 @@ export function createLocalConsoleServer(options) {
         setImmediate(() => options.onShutdown?.());
         return { status: "stopping" };
     });
+    // Native-only control: never included in the browser bridge allowlist.
+    app.post(`${LOCAL_CONSOLE_API_BASE}/control/desktop-session`, {
+        schema: {
+            body: {
+                type: "object",
+                additionalProperties: false,
+                required: ["action"],
+                properties: { action: { enum: ["status", "restore", "exit"] } },
+            },
+            querystring: { type: "object", additionalProperties: false, properties: {} },
+        },
+    }, async (request) => {
+        requireControl(request);
+        if (request.body.action === "status")
+            return desktopSession.status();
+        if (request.body.action === "restore")
+            return desktopSession.restore();
+        const result = await desktopSession.prepareExit();
+        if (result.status === "stopped")
+            setImmediate(() => options.onShutdown?.());
+        return result;
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/control/idle-shutdown`, (request) => {
+        requireControl(request);
+        const lease = operations.tryBeginPackageUpdate();
+        if (lease === null)
+            return { status: "blocked", reason: "console_busy" };
+        nativeShutdownLease = lease;
+        setImmediate(() => options.onShutdown?.());
+        return { status: "stopping" };
+    });
     app.post(`${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
         schema: {
             body: {

package/node_modules/@tutti/shared/dist/schemas/internal/platform-integration.d.ts

@@ -1157,6 +1157,7 @@ export declare const FeishuSetupProjectionSchema: import("@sinclair/typebox").TU
     visibility: import("@sinclair/typebox").TLiteral<"not_recoverable">;
 }>, import("@sinclair/typebox").TObject<{
     state: import("@sinclair/typebox").TLiteral<"connected">;
+    group_url: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>]>;
 export declare const IntegrationConversationBindingRequestSchema: import("@sinclair/typebox").TObject<{
     protocol_version: import("@sinclair/typebox").TLiteral<1>;

package/node_modules/@tutti/shared/dist/schemas/internal/platform-integration.js

@@ -316,7 +316,13 @@ export const FeishuSetupProjectionSchema = Type.Union([
         expires_at: Type.Optional(IsoDateTimeStringSchema),
         visibility: Type.Literal("not_recoverable"),
     }, { additionalProperties: false }),
-    Type.Object({ state: Type.Literal("connected") }, { additionalProperties: false }),
+    Type.Object({
+        state: Type.Literal("connected"),
+        group_url: Type.Optional(Type.String({
+            pattern: "^https://applink\\.feishu\\.cn/client/chat/open\\?chatId=oc_[A-Za-z0-9_-]{1,128}$",
+            maxLength: 256,
+        })),
+    }, { additionalProperties: false }),
 ]);
 export const IntegrationConversationBindingRequestSchema = Type.Object({
     protocol_version: Type.Literal(1),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfey/tenso",
-  "version": "0.1.134",
+  "version": "0.1.135",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",