@easonwumac/computer-linker 0.1.2

package/dist/platform-shell.js

@@ -0,0 +1,124 @@
+import { accessSync, constants } from "node:fs";
+import { delimiter, extname, join } from "node:path";
+export function shellCommand(command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32") {
+        return {
+            command: options.comSpec ?? process.env.ComSpec ?? "cmd.exe",
+            args: ["/d", "/s", "/c", command],
+        };
+    }
+    return {
+        command: options.shell ?? process.env.SHELL ?? "/bin/sh",
+        args: ["-lc", command],
+    };
+}
+export function resolveExecutableCommand(command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== "win32")
+        return command;
+    const env = options.env ?? process.env;
+    const pathEntries = (env.PATH ?? env.Path ?? env.path ?? "")
+        .split(delimiter)
+        .filter(Boolean);
+    const extensions = windowsExecutableExtensions(env);
+    const hasDirectory = command.includes("/") || command.includes("\\");
+    const hasExtension = Boolean(extname(command));
+    const commandCandidates = hasExtension
+        ? [command]
+        : extensions.map((extension) => `${command}${extension}`);
+    const candidates = hasDirectory
+        ? commandCandidates
+        : pathEntries.flatMap((entry) => commandCandidates.map((candidate) => join(entry, candidate)));
+    for (const candidate of candidates) {
+        try {
+            accessSync(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Try the next PATH/PATHEXT candidate.
+        }
+    }
+    return command;
+}
+export function executableCommand(command, args, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const executable = resolveExecutableCommand(command, {
+        platform,
+        env: options.env,
+    });
+    if (!shouldRunExecutableThroughShell(executable, { platform })) {
+        return { command: executable, args };
+    }
+    const line = commandLine([executable, ...args], platform);
+    if (platform === "win32") {
+        return {
+            command: options.comSpec ?? process.env.ComSpec ?? "cmd.exe",
+            args: ["/d", "/s", "/c", `"${line}"`],
+            windowsVerbatimArguments: true,
+        };
+    }
+    return shellCommand(line, {
+        platform,
+        shell: options.shell,
+        comSpec: options.comSpec,
+    });
+}
+export function windowsVerbatimArgumentsOption(command) {
+    return command.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {};
+}
+export function findExecutableCommand(command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const pathEntries = (env.PATH ?? env.Path ?? env.path ?? "")
+        .split(delimiter)
+        .filter(Boolean);
+    const extensions = platform === "win32" ? windowsExecutableExtensions(env) : [""];
+    const hasDirectory = command.includes("/") || command.includes("\\");
+    const hasExtension = Boolean(extname(command));
+    const commandCandidates = platform === "win32" && !hasExtension
+        ? extensions.map((extension) => `${command}${extension}`)
+        : [command];
+    const candidates = hasDirectory
+        ? commandCandidates
+        : pathEntries.flatMap((entry) => commandCandidates.map((candidate) => join(entry, candidate)));
+    for (const candidate of candidates) {
+        try {
+            accessSync(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Try the next PATH/PATHEXT candidate.
+        }
+    }
+    return undefined;
+}
+export function shouldRunExecutableThroughShell(command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    return platform === "win32" && [".bat", ".cmd"].includes(extname(command).toLowerCase());
+}
+function commandLine(parts, platform) {
+    return parts.map((part) => quoteCommandPart(part, platform)).join(" ");
+}
+function quoteCommandPart(part, platform) {
+    if (part === "")
+        return "\"\"";
+    if (platform === "win32")
+        return quoteWindowsCommandPart(part);
+    if (!/[\s"'\\$`!&|;<>(){}[\]*?]/.test(part))
+        return part;
+    return `'${part.replaceAll("'", "'\\''")}'`;
+}
+function quoteWindowsCommandPart(part) {
+    if (!/[\s"&|<>^()%!:\\/]/.test(part))
+        return part;
+    return `"${part.replaceAll("\"", "\"\"")}"`;
+}
+function windowsExecutableExtensions(env) {
+    const raw = env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
+    return raw
+        .split(";")
+        .map((extension) => extension.trim())
+        .filter(Boolean)
+        .map((extension) => (extension.startsWith(".") ? extension : `.${extension}`).toLowerCase());
+}

package/dist/processes.d.ts

@@ -0,0 +1,50 @@
+export interface ManagedProcessSnapshot {
+    processId: string;
+    kind: "shell" | "codex";
+    workspaceId: string;
+    workspaceRoot: string;
+    cwd: string;
+    commandPreview: string;
+    pid?: number;
+    startedAt: string;
+    endedAt?: string;
+    status: "running" | "exited";
+    exitCode: number | null;
+    signal?: string;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+}
+export declare function startManagedProcess(input: {
+    kind: ManagedProcessSnapshot["kind"];
+    workspaceId: string;
+    workspaceRoot: string;
+    cwd: string;
+    command: string;
+    args?: string[];
+    commandPreview: string;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+    stdin?: string;
+}): ManagedProcessSnapshot;
+export declare function listManagedProcesses(input: {
+    workspaceId: string;
+    workspaceRoot: string;
+    kinds?: ManagedProcessSnapshot["kind"][];
+}): ManagedProcessSnapshot[];
+export declare function listAllManagedProcesses(): ManagedProcessSnapshot[];
+export declare function readManagedProcess(input: {
+    processId: string;
+    workspaceId: string;
+    workspaceRoot: string;
+    kinds?: ManagedProcessSnapshot["kind"][];
+}): ManagedProcessSnapshot;
+export declare function stopManagedProcess(input: {
+    processId: string;
+    workspaceId: string;
+    workspaceRoot: string;
+    signal?: string;
+    kinds?: ManagedProcessSnapshot["kind"][];
+}): Promise<ManagedProcessSnapshot>;
+export declare function stopManagedProcessById(processId: string, signal?: string): Promise<ManagedProcessSnapshot>;
+export declare function stopAllManagedProcesses(signal?: string): Promise<ManagedProcessSnapshot[]>;

package/dist/processes.js

@@ -0,0 +1,178 @@
+import { randomUUID } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+import { executableCommand, shellCommand } from "./platform-shell.js";
+const defaultMaxOutputBytes = 128 * 1024;
+const processes = new Map();
+export function startManagedProcess(input) {
+    const processId = `proc_${randomUUID()}`;
+    const detached = process.platform !== "win32";
+    const command = input.args
+        ? executableCommand(input.command, input.args)
+        : shellCommand(input.command);
+    const child = spawn(command.command, command.args, {
+        cwd: input.cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        detached,
+        windowsVerbatimArguments: command.windowsVerbatimArguments,
+    });
+    const managed = {
+        child,
+        processId,
+        kind: input.kind,
+        workspaceId: input.workspaceId,
+        workspaceRoot: input.workspaceRoot,
+        cwd: input.cwd,
+        commandPreview: input.commandPreview,
+        pid: child.pid,
+        startedAt: new Date().toISOString(),
+        status: "running",
+        exitCode: null,
+        timedOut: false,
+        stdout: "",
+        stderr: "",
+        maxOutputBytes: input.maxOutputBytes ?? defaultMaxOutputBytes,
+    };
+    processes.set(processId, managed);
+    child.stdin.end(input.stdin ?? "");
+    child.stdout.on("data", (chunk) => {
+        managed.stdout = appendBounded(managed.stdout, chunk.toString("utf8"), managed.maxOutputBytes);
+    });
+    child.stderr.on("data", (chunk) => {
+        managed.stderr = appendBounded(managed.stderr, chunk.toString("utf8"), managed.maxOutputBytes);
+    });
+    child.on("exit", (code, signal) => {
+        if (managed.timer)
+            clearTimeout(managed.timer);
+        managed.status = "exited";
+        managed.exitCode = code;
+        managed.signal = signal ?? undefined;
+        managed.endedAt = new Date().toISOString();
+    });
+    if (input.timeoutMs && input.timeoutMs > 0) {
+        managed.timer = setTimeout(() => {
+            if (managed.status !== "running")
+                return;
+            managed.timedOut = true;
+            void stopProcess(managed, "SIGTERM");
+        }, input.timeoutMs);
+        managed.timer.unref();
+    }
+    return snapshot(managed);
+}
+export function listManagedProcesses(input) {
+    return [...processes.values()]
+        .filter((process) => process.workspaceId === input.workspaceId && process.workspaceRoot === input.workspaceRoot)
+        .filter((process) => !input.kinds || input.kinds.includes(process.kind))
+        .map(snapshot)
+        .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+export function listAllManagedProcesses() {
+    return [...processes.values()]
+        .map(snapshot)
+        .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+export function readManagedProcess(input) {
+    return snapshot(getProcessForWorkspace(input));
+}
+export async function stopManagedProcess(input) {
+    const process = getProcessForWorkspace(input);
+    return stopProcess(process, normalizeSignal(input.signal));
+}
+export async function stopManagedProcessById(processId, signal) {
+    const process = processes.get(processId);
+    if (!process)
+        throw new Error(`Unknown process: ${processId}`);
+    return stopProcess(process, normalizeSignal(signal));
+}
+export async function stopAllManagedProcesses(signal = "SIGTERM") {
+    const normalizedSignal = normalizeSignal(signal);
+    return Promise.all([...processes.values()].map((process) => stopProcess(process, normalizedSignal)));
+}
+function getProcessForWorkspace(input) {
+    const process = processes.get(input.processId);
+    if (!process ||
+        process.workspaceId !== input.workspaceId ||
+        process.workspaceRoot !== input.workspaceRoot ||
+        (input.kinds && !input.kinds.includes(process.kind))) {
+        throw new Error(`Unknown process for workspace: ${input.processId}`);
+    }
+    return process;
+}
+async function stopProcess(process, signal) {
+    if (process.status !== "running")
+        return snapshot(process);
+    terminateProcessGroup(process, signal);
+    await waitForExit(process, 500);
+    if (signal !== "SIGKILL" && (process.status === "running" || isUnixProcessGroup(process))) {
+        terminateProcessGroup(process, "SIGKILL");
+        await waitForExit(process, 500);
+    }
+    return snapshot(process);
+}
+function snapshot(process) {
+    return {
+        processId: process.processId,
+        kind: process.kind,
+        workspaceId: process.workspaceId,
+        workspaceRoot: process.workspaceRoot,
+        cwd: process.cwd,
+        commandPreview: process.commandPreview,
+        pid: process.pid,
+        startedAt: process.startedAt,
+        endedAt: process.endedAt,
+        status: process.status,
+        exitCode: process.exitCode,
+        signal: process.signal,
+        timedOut: process.timedOut,
+        stdout: process.stdout,
+        stderr: process.stderr,
+    };
+}
+function appendBounded(current, next, maxOutputBytes) {
+    let output = current + next;
+    while (Buffer.byteLength(output, "utf8") > maxOutputBytes) {
+        output = output.slice(Math.max(1, output.length - maxOutputBytes));
+    }
+    return output;
+}
+function normalizeSignal(signal) {
+    if (signal === "SIGKILL" || signal === "SIGINT" || signal === "SIGTERM")
+        return signal;
+    return "SIGTERM";
+}
+function terminateProcessGroup(process, signal) {
+    if (globalThis.process.platform === "win32" && process.pid) {
+        const result = spawnSync("taskkill", ["/pid", String(process.pid), "/t", "/f"], { stdio: "ignore" });
+        if (result.status === 0)
+            return;
+    }
+    if (isUnixProcessGroup(process)) {
+        try {
+            globalThis.process.kill(-process.pid, signal);
+            return;
+        }
+        catch {
+            // Fall back to killing the shell process below.
+        }
+    }
+    process.child.kill(signal);
+}
+function isUnixProcessGroup(process) {
+    return Boolean(process.pid && process.child.spawnargs.length && globalThis.process.platform !== "win32");
+}
+async function waitForExit(process, timeoutMs) {
+    if (process.status !== "running")
+        return true;
+    return new Promise((resolve) => {
+        const onExit = () => {
+            clearTimeout(timeout);
+            resolve(true);
+        };
+        const timeout = setTimeout(() => {
+            process.child.off("exit", onExit);
+            resolve(false);
+        }, timeoutMs);
+        process.child.once("exit", onExit);
+        timeout.unref();
+    });
+}

package/dist/profile.d.ts

@@ -0,0 +1,159 @@
+import type { LocalPortConfig } from "./permissions.js";
+export type ChatGptProfileMode = "safe" | "coding" | "full";
+export interface ChatGptProfileOptions {
+    publicBaseUrl?: string;
+}
+export interface ChatGptModelGuide {
+    summary: string;
+    mcpEntrypoint: "computer_operation";
+    jsonApiEntrypoint: {
+        endpoint: "POST /api/v1/control";
+        action: "computer_operation";
+        availability: "local-or-trusted-private-only";
+        publicTunnelDefault: "blocked-when-publicMcpOnly";
+    };
+    startupChecklist: string[];
+    operationSelection: Array<{
+        intent: string;
+        op: string;
+        when: string;
+    }>;
+    guardrails: string[];
+}
+export interface ChatGptWorkflowRecipe {
+    name: string;
+    purpose: string;
+    steps: Array<{
+        tool: "get_computer_info" | "computer_operation" | "get_operation_history";
+        input?: Record<string, unknown>;
+        why: string;
+    }>;
+}
+export interface ConnectionProfile {
+    name: "computer-linker";
+    machineId?: string;
+    machineName: string;
+    configPath: string;
+    stdio: {
+        command: string;
+        args: string[];
+    };
+    http: {
+        localMcpUrl: string;
+        publicMcpUrl: string;
+        localApiUrl: string;
+        publicApiUrl: string | null;
+        publicApiAvailable: boolean;
+        auth: {
+            mode: "loopback-only" | "owner-token-or-oauth";
+            header?: string;
+            bearerToken?: string;
+        };
+    };
+}
+export interface ChatGptConnectProfile {
+    kind: "chatgpt-mcp-app";
+    schemaVersion: 1;
+    mode: ChatGptProfileMode;
+    name: string;
+    description: string;
+    machineId?: string;
+    machineName: string;
+    configPath: string;
+    mcpServerUrl: string;
+    publicBaseUrl: string | null;
+    localMcpUrl: string;
+    auth: {
+        preferred: "oauth";
+        fallback: "bearer";
+        oauth: {
+            discovery: string;
+            scopes: string[];
+        };
+        bearer: {
+            header: string | null;
+            token?: string;
+            alternateHeader: string | null;
+        };
+        notes: string[];
+    };
+    appManifest: {
+        appName: string;
+        appType: "remote-mcp";
+        serverUrl: string;
+        authType: "oauth-or-bearer";
+    };
+    setup: {
+        developerMode: true;
+        requiredReachability: "public-https";
+        connectionType: "Remote MCP";
+        mode: ChatGptProfileMode;
+        firstPrompt: string;
+        verifyWith: string[];
+    };
+    tools: string[];
+    operationShape: {
+        recommendedTool: "computer_operation";
+        envelope: {
+            scope: string;
+            op: string;
+            target: string;
+            input: Record<string, unknown>;
+            options: Record<string, unknown>;
+        };
+        notes: string[];
+    };
+    recommendedFlow: Array<{
+        step: number;
+        tool: string;
+        purpose: string;
+        input?: Record<string, unknown>;
+    }>;
+    modelGuide: ChatGptModelGuide;
+    workflowRecipes: ChatGptWorkflowRecipe[];
+    gptInstructions: string[];
+    warnings: string[];
+}
+export interface ChatGptAppManifest {
+    kind: "chatgpt-app-manifest";
+    schemaVersion: 1;
+    mode: ChatGptProfileMode;
+    appName: string;
+    description: string;
+    appType: "remote-mcp";
+    mcpServerUrl: string;
+    auth: {
+        preferred: "oauth";
+        fallback: "bearer";
+        scopes: string[];
+    };
+    tools: string[];
+    firstPrompt: string;
+    warnings: string[];
+}
+export interface ChatGptConnectorConfig {
+    kind: "chatgpt-connector-config";
+    schemaVersion: 1;
+    mode: ChatGptProfileMode;
+    displayName: string;
+    mcpServerUrl: string;
+    connectionType: "Remote MCP";
+    auth: {
+        type: "oauth-or-bearer";
+        oauthScopes: string[];
+        bearerHeader: string | null;
+        alternateBearerHeader: string | null;
+    };
+    setup: ChatGptConnectProfile["setup"];
+    recommendedFlow: ChatGptConnectProfile["recommendedFlow"];
+    modelGuide: ChatGptConnectProfile["modelGuide"];
+    workflowRecipes: ChatGptConnectProfile["workflowRecipes"];
+    gptInstructions: string[];
+    warnings: string[];
+}
+export declare function connectionProfile(config: LocalPortConfig, includeSecrets?: boolean): ConnectionProfile;
+export declare function parseChatGptProfileMode(value: string | undefined, command?: string): ChatGptProfileMode;
+export declare function chatGptConnectProfile(config: LocalPortConfig, includeSecrets?: boolean, mode?: ChatGptProfileMode, options?: ChatGptProfileOptions): ChatGptConnectProfile;
+export declare function chatGptAppManifest(config: LocalPortConfig, mode?: ChatGptProfileMode, options?: ChatGptProfileOptions): ChatGptAppManifest;
+export declare function chatGptConnectorConfig(config: LocalPortConfig, includeSecrets?: boolean, mode?: ChatGptProfileMode, options?: ChatGptProfileOptions): ChatGptConnectorConfig;
+export declare function localPublicBaseUrl(host: string, port: number): string;