@xfey/tutti 0.1.54 → 0.1.55

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

@@ -0,0 +1,138 @@
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { requireDesktopCommand, runDesktopCommand, } from "./platform.js";
+const BUNDLE_IDENTIFIER = "now.tutti.desktop";
+const LAUNCH_SERVICES_REGISTER = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
+function plistValue(runner, plistPath, key) {
+    const result = runner("/usr/bin/plutil", ["-extract", key, "raw", "-o", "-", plistPath]);
+    return result.status === 0 ? result.stdout.trim() : null;
+}
+export function renderMacosHandlerTemplate(template, identity) {
+    const nodeToken = "__TUTTI_NODE_EXECUTABLE_STRING__";
+    const cliToken = "__TUTTI_CLI_ENTRYPOINT_STRING__";
+    if (!template.includes(nodeToken) || !template.includes(cliToken)) {
+        throw new Error("The packaged macOS desktop handler template is invalid.");
+    }
+    return template
+        .replace(nodeToken, JSON.stringify(identity.nodeExecutable))
+        .replace(cliToken, JSON.stringify(identity.cliEntrypoint));
+}
+export function createMacosDesktopAdapter(options) {
+    const runner = options.runner ?? runDesktopCommand;
+    const applicationsDir = join(options.homeDir, "Applications");
+    const entryPath = join(applicationsDir, "Tutti.app");
+    const templatePath = join(options.assetRoot, "macos-handler.applescript");
+    const iconPath = join(options.assetRoot, "Tutti.icns");
+    const inspect = () => {
+        if (!existsSync(entryPath)) {
+            return "missing";
+        }
+        const plistPath = join(entryPath, "Contents", "Info.plist");
+        if (!existsSync(plistPath)) {
+            return "conflict";
+        }
+        const identifier = plistValue(runner, plistPath, "CFBundleIdentifier");
+        const managed = plistValue(runner, plistPath, "TuttiManaged");
+        const schemaVersion = plistValue(runner, plistPath, "TuttiSchemaVersion");
+        return identifier === BUNDLE_IDENTIFIER && managed === "true" && schemaVersion === "1"
+            ? "owned"
+            : "conflict";
+    };
+    return {
+        platform: "darwin",
+        entryPath,
+        inspect,
+        install(identity) {
+            if (inspect() === "conflict") {
+                throw new Error("An application not managed by Tutti already occupies the desktop entry.");
+            }
+            if (!existsSync(templatePath) || !existsSync(iconPath)) {
+                throw new Error("The packaged macOS desktop assets are unavailable.");
+            }
+            mkdirSync(applicationsDir, { recursive: true });
+            const temporaryRoot = mkdtempSync(join(applicationsDir, ".tutti-desktop-"));
+            const sourcePath = join(temporaryRoot, "handler.applescript");
+            const compiledPath = join(temporaryRoot, "Tutti.app");
+            const previousPath = join(temporaryRoot, "Tutti.previous.app");
+            let previousMoved = false;
+            let installedMoved = false;
+            try {
+                const template = readFileSync(templatePath, "utf8");
+                writeFileSync(sourcePath, renderMacosHandlerTemplate(template, identity), {
+                    encoding: "utf8",
+                    mode: 0o600,
+                });
+                requireDesktopCommand(runner, "/usr/bin/osacompile", ["-l", "AppleScript", "-o", compiledPath, sourcePath], "macOS desktop handler compilation");
+                const plistPath = join(compiledPath, "Contents", "Info.plist");
+                const resourcesPath = join(compiledPath, "Contents", "Resources");
+                mkdirSync(resourcesPath, { recursive: true });
+                copyFileSync(iconPath, join(resourcesPath, "Tutti.icns"));
+                const replaceString = (key, value) => requireDesktopCommand(runner, "/usr/bin/plutil", ["-replace", key, "-string", value, plistPath], `macOS ${key} metadata update`);
+                replaceString("CFBundleIdentifier", BUNDLE_IDENTIFIER);
+                replaceString("CFBundleName", "Tutti");
+                replaceString("CFBundleDisplayName", "Tutti");
+                replaceString("CFBundleIconFile", "Tutti.icns");
+                requireDesktopCommand(runner, "/usr/bin/plutil", ["-insert", "LSUIElement", "-bool", "YES", plistPath], "macOS background app metadata update");
+                requireDesktopCommand(runner, "/usr/bin/plutil", ["-insert", "TuttiManaged", "-bool", "YES", plistPath], "macOS ownership metadata update");
+                requireDesktopCommand(runner, "/usr/bin/plutil", ["-insert", "TuttiSchemaVersion", "-integer", "1", plistPath], "macOS schema metadata update");
+                requireDesktopCommand(runner, "/usr/bin/plutil", [
+                    "-insert",
+                    "CFBundleURLTypes",
+                    "-json",
+                    JSON.stringify([
+                        {
+                            CFBundleTypeRole: "Viewer",
+                            CFBundleURLName: BUNDLE_IDENTIFIER,
+                            CFBundleURLSchemes: ["tutti"],
+                        },
+                    ]),
+                    plistPath,
+                ], "macOS URL scheme metadata update");
+                requireDesktopCommand(runner, "/usr/bin/codesign", ["--force", "--sign", "-", compiledPath], "macOS desktop handler signing");
+                if (existsSync(entryPath)) {
+                    renameSync(entryPath, previousPath);
+                    previousMoved = true;
+                }
+                renameSync(compiledPath, entryPath);
+                installedMoved = true;
+                requireDesktopCommand(runner, LAUNCH_SERVICES_REGISTER, ["-f", entryPath], "macOS URL scheme registration");
+                if (previousMoved) {
+                    rmSync(previousPath, { recursive: true, force: true });
+                    previousMoved = false;
+                }
+            }
+            catch (error) {
+                if (installedMoved && existsSync(entryPath)) {
+                    rmSync(entryPath, { recursive: true, force: true });
+                }
+                if (previousMoved && existsSync(previousPath)) {
+                    renameSync(previousPath, entryPath);
+                }
+                throw error;
+            }
+            finally {
+                rmSync(temporaryRoot, { recursive: true, force: true });
+            }
+        },
+        remove() {
+            const inspection = inspect();
+            if (inspection === "conflict") {
+                throw new Error("The existing macOS desktop entry is not managed by Tutti.");
+            }
+            if (inspection === "missing") {
+                return;
+            }
+            runner(LAUNCH_SERVICES_REGISTER, ["-u", entryPath]);
+            rmSync(entryPath, { recursive: true, force: true });
+        },
+    };
+}
+export function macosDesktopRequirementsAvailable(assetRoot) {
+    return (existsSync("/usr/bin/osacompile") &&
+        existsSync("/usr/bin/plutil") &&
+        existsSync("/usr/bin/codesign") &&
+        existsSync(LAUNCH_SERVICES_REGISTER) &&
+        existsSync(join(assetRoot, "macos-handler.applescript")) &&
+        existsSync(join(assetRoot, "Tutti.icns")));
+}
+//# sourceMappingURL=macos.js.map

package/dist/server-shell/desktop-integration/manager.d.ts

@@ -0,0 +1,40 @@
+import { type DesktopCommandRunner, type DesktopInstallationIdentity, type DesktopPlatformAdapter } from "./platform.js";
+export type DesktopIntegrationResult = {
+    status: "installed";
+    entry_path: string;
+    changed: boolean;
+} | {
+    status: "removed";
+    entry_path: string;
+    changed: boolean;
+} | {
+    status: "unavailable";
+    reason_code: "unsupported_platform" | "package_not_global" | "custom_tutti_home" | "headless" | "requirements_missing" | "record_invalid" | "entry_conflict" | "operation_failed";
+    reason: string;
+    entry_path?: string;
+} | {
+    status: "skipped";
+    reason_code: "not_eligible" | "removed";
+};
+type ManagerContext = {
+    tuttiHome: string;
+    adapter: DesktopPlatformAdapter;
+    identity: DesktopInstallationIdentity;
+    now: () => Date;
+};
+export declare function ensureDesktopIntegration(context: ManagerContext): DesktopIntegrationResult;
+export declare function installDesktopIntegration(context: ManagerContext): DesktopIntegrationResult;
+export declare function inspectDesktopIntegration(context: ManagerContext): DesktopIntegrationResult;
+export declare function removeDesktopIntegration(context: ManagerContext): DesktopIntegrationResult;
+declare function createRealContext(options: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    now?: () => Date;
+    runner?: DesktopCommandRunner;
+    requireStableGlobal?: boolean;
+}): ManagerContext | DesktopIntegrationResult;
+export declare function ensureDesktopIntegrationAutomatically(options?: Parameters<typeof createRealContext>[0]): DesktopIntegrationResult;
+export declare function runDesktopIntegrationCommand(action: "install" | "status" | "remove", options?: Parameters<typeof createRealContext>[0]): DesktopIntegrationResult;
+export {};
+//# sourceMappingURL=manager.d.ts.map

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

@@ -0,0 +1,223 @@
+import { existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { readCliPackageIdentity } from "../cli/version.js";
+import { createLinuxDesktopAdapter, findDesktopExecutable, linuxDesktopRequirementsAvailable, } from "./linux.js";
+import { createMacosDesktopAdapter, macosDesktopRequirementsAvailable } from "./macos.js";
+import { runDesktopCommand, } from "./platform.js";
+import { readDesktopIntegrationRecord, writeDesktopIntegrationRecord, } from "./record.js";
+const PUBLISHED_CLI_PACKAGE_NAME = "@xfey/tutti";
+function desktopAssetRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "../../../desktop-assets");
+}
+function readRecordSafely(tuttiHome) {
+    try {
+        return { kind: "ok", record: readDesktopIntegrationRecord(tuttiHome) };
+    }
+    catch {
+        return { kind: "invalid" };
+    }
+}
+function recordFor(context, state) {
+    return {
+        schema_version: 1,
+        state,
+        platform: context.adapter.platform,
+        entry_path: context.adapter.entryPath,
+        protocol: "tutti",
+        package_version: context.identity.packageVersion,
+        node_executable: context.identity.nodeExecutable,
+        cli_entrypoint: context.identity.cliEntrypoint,
+        updated_at: context.now().toISOString(),
+    };
+}
+function identityMatches(record, context) {
+    return (record.platform === context.adapter.platform &&
+        record.entry_path === context.adapter.entryPath &&
+        record.package_version === context.identity.packageVersion &&
+        record.node_executable === context.identity.nodeExecutable &&
+        record.cli_entrypoint === context.identity.cliEntrypoint);
+}
+function unavailable(reasonCode, reason, entryPath) {
+    return {
+        status: "unavailable",
+        reason_code: reasonCode,
+        reason,
+        ...(entryPath === undefined ? {} : { entry_path: entryPath }),
+    };
+}
+export function ensureDesktopIntegration(context) {
+    const read = readRecordSafely(context.tuttiHome);
+    if (read.kind === "invalid") {
+        return unavailable("record_invalid", "The desktop integration record is invalid and was not overwritten.", context.adapter.entryPath);
+    }
+    const record = read.record;
+    if (record?.state === "removed") {
+        return { status: "skipped", reason_code: "removed" };
+    }
+    let inspection;
+    try {
+        inspection = context.adapter.inspect();
+    }
+    catch {
+        return unavailable("operation_failed", "The desktop entry could not be inspected.", context.adapter.entryPath);
+    }
+    if (inspection === "conflict") {
+        return unavailable("entry_conflict", "The desktop entry path is occupied by an application not managed by Tutti.", context.adapter.entryPath);
+    }
+    if (record?.state === "installed" && inspection === "missing") {
+        writeDesktopIntegrationRecord(context.tuttiHome, recordFor(context, "removed"));
+        return { status: "removed", entry_path: context.adapter.entryPath, changed: true };
+    }
+    if (record?.state === "installed" && inspection === "owned" && identityMatches(record, context)) {
+        return { status: "installed", entry_path: context.adapter.entryPath, changed: false };
+    }
+    try {
+        context.adapter.install(context.identity);
+        writeDesktopIntegrationRecord(context.tuttiHome, recordFor(context, "installed"));
+        return { status: "installed", entry_path: context.adapter.entryPath, changed: true };
+    }
+    catch {
+        return unavailable("operation_failed", "Tutti could not install the user-level desktop entry.", context.adapter.entryPath);
+    }
+}
+export function installDesktopIntegration(context) {
+    const read = readRecordSafely(context.tuttiHome);
+    if (read.kind === "invalid") {
+        return unavailable("record_invalid", "The desktop integration record is invalid and was not overwritten.", context.adapter.entryPath);
+    }
+    try {
+        if (context.adapter.inspect() === "conflict") {
+            return unavailable("entry_conflict", "The desktop entry path is occupied by an application not managed by Tutti.", context.adapter.entryPath);
+        }
+        context.adapter.install(context.identity);
+        writeDesktopIntegrationRecord(context.tuttiHome, recordFor(context, "installed"));
+        return { status: "installed", entry_path: context.adapter.entryPath, changed: true };
+    }
+    catch {
+        return unavailable("operation_failed", "Tutti could not install or repair the user-level desktop entry.", context.adapter.entryPath);
+    }
+}
+export function inspectDesktopIntegration(context) {
+    const read = readRecordSafely(context.tuttiHome);
+    if (read.kind === "invalid") {
+        return unavailable("record_invalid", "The desktop integration record is invalid.", context.adapter.entryPath);
+    }
+    try {
+        const inspection = context.adapter.inspect();
+        if (inspection === "conflict") {
+            return unavailable("entry_conflict", "The desktop entry path is occupied by an application not managed by Tutti.", context.adapter.entryPath);
+        }
+        if (inspection === "owned" && read.record?.state !== "removed") {
+            return { status: "installed", entry_path: context.adapter.entryPath, changed: false };
+        }
+        return { status: "removed", entry_path: context.adapter.entryPath, changed: false };
+    }
+    catch {
+        return unavailable("operation_failed", "The desktop entry could not be inspected.", context.adapter.entryPath);
+    }
+}
+export function removeDesktopIntegration(context) {
+    const read = readRecordSafely(context.tuttiHome);
+    if (read.kind === "invalid") {
+        return unavailable("record_invalid", "The desktop integration record is invalid and the entry was not removed.", context.adapter.entryPath);
+    }
+    try {
+        if (context.adapter.inspect() === "conflict") {
+            return unavailable("entry_conflict", "The desktop entry is not managed by Tutti and was not removed.", context.adapter.entryPath);
+        }
+        context.adapter.remove();
+        writeDesktopIntegrationRecord(context.tuttiHome, recordFor(context, "removed"));
+        return { status: "removed", entry_path: context.adapter.entryPath, changed: true };
+    }
+    catch {
+        return unavailable("operation_failed", "Tutti could not remove the user-level desktop entry.", context.adapter.entryPath);
+    }
+}
+function stableGlobalPackage(options) {
+    const npmExecutable = findDesktopExecutable("npm", options.env);
+    if (npmExecutable === null) {
+        return false;
+    }
+    const result = options.runner(npmExecutable, ["root", "--global"]);
+    const globalRoot = result.stdout.trim();
+    if (result.status !== 0 || !isAbsolute(globalRoot)) {
+        return false;
+    }
+    const expectedRoot = join(globalRoot, ...PUBLISHED_CLI_PACKAGE_NAME.split("/"));
+    if (!existsSync(expectedRoot)) {
+        return false;
+    }
+    try {
+        return realpathSync(expectedRoot) === realpathSync(options.packageRoot);
+    }
+    catch {
+        return false;
+    }
+}
+function createRealContext(options) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const runner = options.runner ?? runDesktopCommand;
+    const packageIdentity = readCliPackageIdentity();
+    if (packageIdentity.name !== PUBLISHED_CLI_PACKAGE_NAME ||
+        (options.requireStableGlobal !== false &&
+            !stableGlobalPackage({ packageRoot: packageIdentity.root, env, runner }))) {
+        return unavailable("package_not_global", "Desktop integration requires a stable global @xfey/tutti installation.");
+    }
+    if (env.TUTTI_HOME !== undefined && env.TUTTI_HOME.trim() !== "") {
+        return unavailable("custom_tutti_home", "Desktop integration is available only for the default Tutti home.");
+    }
+    if (platform !== "darwin" && platform !== "linux") {
+        return unavailable("unsupported_platform", "Desktop integration supports macOS and Linux.");
+    }
+    const homeDir = env.HOME !== undefined && isAbsolute(env.HOME) ? env.HOME : homedir();
+    const assetRoot = desktopAssetRoot();
+    if ((platform === "darwin" && !macosDesktopRequirementsAvailable(assetRoot)) ||
+        (platform === "linux" && !linuxDesktopRequirementsAvailable(assetRoot, env))) {
+        return unavailable("requirements_missing", "The required user-level desktop registration tools are unavailable.");
+    }
+    const cliEntrypoint = process.argv[1];
+    if (cliEntrypoint === undefined || cliEntrypoint.trim() === "") {
+        return unavailable("requirements_missing", "The Tutti CLI entrypoint is unavailable.");
+    }
+    const adapter = platform === "darwin"
+        ? createMacosDesktopAdapter({ homeDir, assetRoot, runner })
+        : createLinuxDesktopAdapter({ homeDir, assetRoot, env, runner });
+    return {
+        tuttiHome: resolveTuttiHome(undefined, cwd),
+        adapter,
+        identity: {
+            packageVersion: packageIdentity.version,
+            nodeExecutable: resolve(process.execPath),
+            cliEntrypoint: resolve(cliEntrypoint),
+        },
+        now: options.now ?? (() => new Date()),
+    };
+}
+export function ensureDesktopIntegrationAutomatically(options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    if (platform === "linux" && env.DISPLAY === undefined && env.WAYLAND_DISPLAY === undefined) {
+        return unavailable("headless", "No graphical Linux desktop session is available.");
+    }
+    const context = createRealContext(options);
+    return "adapter" in context ? ensureDesktopIntegration(context) : context;
+}
+export function runDesktopIntegrationCommand(action, options = {}) {
+    const context = createRealContext(options);
+    if (!("adapter" in context)) {
+        return context;
+    }
+    if (action === "status") {
+        return inspectDesktopIntegration(context);
+    }
+    if (action === "remove") {
+        return removeDesktopIntegration(context);
+    }
+    return installDesktopIntegration(context);
+}
+//# sourceMappingURL=manager.js.map

package/dist/server-shell/desktop-integration/platform.d.ts

@@ -0,0 +1,23 @@
+export type DesktopPlatform = "darwin" | "linux";
+export type DesktopInstallationIdentity = {
+    packageVersion: string;
+    nodeExecutable: string;
+    cliEntrypoint: string;
+};
+export type DesktopEntryInspection = "missing" | "owned" | "conflict";
+export type DesktopPlatformAdapter = {
+    platform: DesktopPlatform;
+    entryPath: string;
+    inspect: () => DesktopEntryInspection;
+    install: (identity: DesktopInstallationIdentity) => void;
+    remove: () => void;
+};
+export type DesktopCommandResult = {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};
+export type DesktopCommandRunner = (executable: string, args: readonly string[]) => DesktopCommandResult;
+export declare const runDesktopCommand: DesktopCommandRunner;
+export declare function requireDesktopCommand(runner: DesktopCommandRunner, executable: string, args: readonly string[], description: string): DesktopCommandResult;
+//# sourceMappingURL=platform.d.ts.map

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

@@ -0,0 +1,21 @@
+import { spawnSync } from "node:child_process";
+export const runDesktopCommand = (executable, args) => {
+    const result = spawnSync(executable, [...args], {
+        encoding: "utf8",
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+    };
+};
+export function requireDesktopCommand(runner, executable, args, description) {
+    const result = runner(executable, args);
+    if (result.status !== 0) {
+        throw new Error(`${description} failed.`);
+    }
+    return result;
+}
+//# sourceMappingURL=platform.js.map

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

@@ -0,0 +1,9 @@
+export declare const TUTTI_DESKTOP_PROJECTS_URL = "tutti://projects";
+export type TuttiDesktopIntent = {
+    kind: "projects";
+};
+export declare class TuttiDesktopProtocolError extends Error {
+    constructor();
+}
+export declare function parseTuttiDesktopUrl(value: string): TuttiDesktopIntent;
+//# sourceMappingURL=protocol.d.ts.map

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

@@ -0,0 +1,28 @@
+export const TUTTI_DESKTOP_PROJECTS_URL = "tutti://projects";
+export class TuttiDesktopProtocolError extends Error {
+    constructor() {
+        super("Only the fixed tutti://projects desktop destination is supported.");
+        this.name = "TuttiDesktopProtocolError";
+    }
+}
+export function parseTuttiDesktopUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new TuttiDesktopProtocolError();
+    }
+    if (url.protocol !== "tutti:" ||
+        url.hostname !== "projects" ||
+        (url.pathname !== "" && url.pathname !== "/") ||
+        url.username !== "" ||
+        url.password !== "" ||
+        url.port !== "" ||
+        url.search !== "" ||
+        url.hash !== "") {
+        throw new TuttiDesktopProtocolError();
+    }
+    return { kind: "projects" };
+}
+//# sourceMappingURL=protocol.js.map

package/dist/server-shell/desktop-integration/record.d.ts

@@ -0,0 +1,17 @@
+import type { DesktopPlatform } from "./platform.js";
+export type DesktopIntegrationRecord = {
+    schema_version: 1;
+    state: "installed" | "removed";
+    platform: DesktopPlatform;
+    entry_path: string;
+    protocol: "tutti";
+    package_version: string;
+    node_executable: string;
+    cli_entrypoint: string;
+    updated_at: string;
+};
+export declare function parseDesktopIntegrationRecord(value: unknown): DesktopIntegrationRecord;
+export declare function desktopIntegrationRecordPath(tuttiHome: string): string;
+export declare function readDesktopIntegrationRecord(tuttiHome: string): DesktopIntegrationRecord | null;
+export declare function writeDesktopIntegrationRecord(tuttiHome: string, record: DesktopIntegrationRecord): void;
+//# sourceMappingURL=record.d.ts.map

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

@@ -0,0 +1,74 @@
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+const RECORD_KEYS = [
+    "schema_version",
+    "state",
+    "platform",
+    "entry_path",
+    "protocol",
+    "package_version",
+    "node_executable",
+    "cli_entrypoint",
+    "updated_at",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "";
+}
+export function parseDesktopIntegrationRecord(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => !RECORD_KEYS.includes(key))) {
+        throw new Error("The desktop integration record is invalid.");
+    }
+    if (value.schema_version !== 1 ||
+        (value.state !== "installed" && value.state !== "removed") ||
+        (value.platform !== "darwin" && value.platform !== "linux") ||
+        value.protocol !== "tutti" ||
+        !isNonEmptyString(value.entry_path) ||
+        !isNonEmptyString(value.package_version) ||
+        !isNonEmptyString(value.node_executable) ||
+        !isNonEmptyString(value.cli_entrypoint) ||
+        !isNonEmptyString(value.updated_at) ||
+        Number.isNaN(Date.parse(value.updated_at))) {
+        throw new Error("The desktop integration record is invalid.");
+    }
+    return value;
+}
+export function desktopIntegrationRecordPath(tuttiHome) {
+    return join(tuttiHome, "desktop", "integration.json");
+}
+export function readDesktopIntegrationRecord(tuttiHome) {
+    const path = desktopIntegrationRecordPath(tuttiHome);
+    if (!existsSync(path)) {
+        return null;
+    }
+    return parseDesktopIntegrationRecord(JSON.parse(readFileSync(path, "utf8")));
+}
+export function writeDesktopIntegrationRecord(tuttiHome, record) {
+    const validated = parseDesktopIntegrationRecord(record);
+    const path = desktopIntegrationRecordPath(tuttiHome);
+    const directory = dirname(path);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    chmodSync(directory, 0o700);
+    const temporaryPath = join(directory, `.integration-${process.pid}-${Date.now()}.tmp`);
+    let descriptor;
+    try {
+        descriptor = openSync(temporaryPath, "wx", 0o600);
+        writeFileSync(descriptor, `${JSON.stringify(validated, null, 2)}\n`, "utf8");
+        closeSync(descriptor);
+        descriptor = undefined;
+        chmodSync(temporaryPath, 0o600);
+        renameSync(temporaryPath, path);
+        chmodSync(path, 0o600);
+    }
+    finally {
+        if (descriptor !== undefined) {
+            closeSync(descriptor);
+        }
+        if (existsSync(temporaryPath)) {
+            unlinkSync(temporaryPath);
+        }
+    }
+}
+//# sourceMappingURL=record.js.map

package/dist/server-shell/local-console/invocation-context.d.ts

@@ -1,14 +1,21 @@
 export declare const LOCAL_CONSOLE_INVOCATION_ENV_KEYS: readonly ["DBUS_SESSION_BUS_ADDRESS", "DISPLAY", "LANG", "LC_ALL", "LC_CTYPE", "PATH", "TUTTI_HOST_ENDPOINT_HOST", "TUTTI_HOST_ENDPOINT_PORT", "TUTTI_RELAY_URL", "WAYLAND_DISPLAY", "XDG_CURRENT_DESKTOP"];
 export type LocalConsoleInvocationEnvironment = Partial<Record<(typeof LOCAL_CONSOLE_INVOCATION_ENV_KEYS)[number], string>>;
 export type LocalConsoleInvocationContext = {
+    source: "terminal";
     currentDirectory: string;
     environment: LocalConsoleInvocationEnvironment;
+} | {
+    source: "desktop";
+    environment: LocalConsoleInvocationEnvironment;
 };
 export declare function collectLocalConsoleInvocationEnvironment(env: NodeJS.ProcessEnv): LocalConsoleInvocationEnvironment;
 export declare function createLocalConsoleInvocationContext(options: {
     cwd: string;
     env: NodeJS.ProcessEnv;
 }): LocalConsoleInvocationContext;
+export declare function createDesktopLocalConsoleInvocationContext(options: {
+    env: NodeJS.ProcessEnv;
+}): LocalConsoleInvocationContext;
 export declare function createLocalConsoleServiceEnvironment(options: {
     env: NodeJS.ProcessEnv;
     tuttiHome: string;

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

@@ -24,21 +24,20 @@ export function collectLocalConsoleInvocationEnvironment(env) {
 }
 export function createLocalConsoleInvocationContext(options) {
     return {
+        source: "terminal",
         currentDirectory: resolve(options.cwd),
         environment: collectLocalConsoleInvocationEnvironment(options.env),
     };
 }
+export function createDesktopLocalConsoleInvocationContext(options) {
+    return {
+        source: "desktop",
+        environment: collectLocalConsoleInvocationEnvironment(options.env),
+    };
+}
 export function createLocalConsoleServiceEnvironment(options) {
     const environment = { TUTTI_HOME: options.tuttiHome };
-    for (const key of [
-        "HOME",
-        "LANG",
-        "LC_ALL",
-        "LC_CTYPE",
-        "LOGNAME",
-        "TMPDIR",
-        "USER",
-    ]) {
+    for (const key of ["HOME", "LANG", "LC_ALL", "LC_CTYPE", "LOGNAME", "TMPDIR", "USER"]) {
         const value = options.env[key];
         if (value !== undefined && value !== "") {
             environment[key] = value;

package/dist/server-shell/local-console/managed-console.d.ts

@@ -24,6 +24,7 @@ export declare function ensureLocalConsole(options?: {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
     fetchImpl?: FetchLike;
+    source?: "terminal" | "desktop";
 }): Promise<{
     url: string;
     endpoint: LocalConsoleRuntimeEndpoint;