@easonwumac/computer-linker 0.1.2

package/dist/capability-policy.d.ts

@@ -0,0 +1,22 @@
+import type { PathPermissions } from "./permissions.js";
+import type { WorkspaceOperationName } from "./workspace-operations.js";
+export type CapabilityName = "fs:read" | "fs:write" | "search:read" | "history:read" | "git:read" | "git:write" | "package:run" | "process:manage" | "shell:run" | "codex:readOnly" | "codex:write" | "screen:capture" | "network:false";
+export interface CapabilityPolicy {
+    version: 1;
+    source: "derived-from-workspace-permissions";
+    capabilities: CapabilityName[];
+    limits: {
+        maxRuntimeSeconds: number;
+        maxFileBytes: number;
+        maxSearchResults: number;
+        maxBatchOperations: number;
+    };
+    notes: string[];
+}
+export interface OperationCapabilityPolicy {
+    operation: WorkspaceOperationName;
+    capabilities: CapabilityName[];
+    limits?: Partial<CapabilityPolicy["limits"]>;
+}
+export declare function workspaceCapabilityPolicy(permissions: PathPermissions): CapabilityPolicy;
+export declare function operationCapabilityPolicy(operation: WorkspaceOperationName): OperationCapabilityPolicy;

package/dist/capability-policy.js

@@ -0,0 +1,103 @@
+const DEFAULT_LIMITS = {
+    maxRuntimeSeconds: 3600,
+    maxFileBytes: 256 * 1024,
+    maxSearchResults: 1000,
+    maxBatchOperations: 25,
+};
+export function workspaceCapabilityPolicy(permissions) {
+    const capabilities = new Set(["network:false"]);
+    if (permissions.read) {
+        capabilities.add("fs:read");
+        capabilities.add("search:read");
+        capabilities.add("history:read");
+        capabilities.add("git:read");
+    }
+    if (permissions.write) {
+        capabilities.add("fs:write");
+        capabilities.add("git:write");
+    }
+    if (permissions.shell) {
+        capabilities.add("package:run");
+        capabilities.add("process:manage");
+        capabilities.add("shell:run");
+    }
+    if (permissions.codex) {
+        capabilities.add("codex:readOnly");
+        capabilities.add("codex:write");
+        capabilities.add("process:manage");
+    }
+    if (permissions.screen) {
+        capabilities.add("screen:capture");
+    }
+    return {
+        version: 1,
+        source: "derived-from-workspace-permissions",
+        capabilities: [...capabilities],
+        limits: DEFAULT_LIMITS,
+        notes: [
+            "This policy is derived from the current read/write/shell/codex workspace permissions.",
+            "network:false means Computer Linker does not grant network access as a first-class capability; shell, package, and Codex processes may still use the host network if the underlying tools do.",
+            "maxRuntimeSeconds is the upper bound accepted by Computer Linker for shell, process, package, and Codex timeouts.",
+        ],
+    };
+}
+export function operationCapabilityPolicy(operation) {
+    const capabilities = operationCapabilities(operation);
+    const limits = operationLimits(operation);
+    return {
+        operation,
+        capabilities,
+        limits: Object.keys(limits).length > 0 ? limits : undefined,
+    };
+}
+function operationCapabilities(operation) {
+    if (operation === "batch")
+        return ["network:false"];
+    if (operation === "history" || operation === "history_insight")
+        return ["history:read", "network:false"];
+    if (operation === "find_files" || operation === "search_text" || operation === "search_symbols")
+        return ["search:read", "fs:read", "network:false"];
+    if (operation.startsWith("git_") || operation === "repo_status" || operation === "git_changes" || operation === "git_diff" || operation === "git_log" || operation === "git_show" || operation === "change_summary") {
+        return gitOperationCapabilities(operation);
+    }
+    if (operation === "package_run" || operation === "package_start")
+        return ["package:run", "process:manage", "network:false"];
+    if (operation === "command")
+        return ["shell:run", "network:false"];
+    if (operation === "process_start" || operation === "process_list" || operation === "process_read" || operation === "process_stop")
+        return ["process:manage", "network:false"];
+    if (operation === "codex" || operation === "codex_start" || operation === "codex_plan" || operation === "codex_review" || operation === "codex_fix" || operation === "codex_test" || operation === "codex_continue" || operation === "codex_runs") {
+        return codexOperationCapabilities(operation);
+    }
+    if (operation === "screen_list" || operation === "screen_capture" || operation === "screen_capture_window" || operation === "screen_capture_process") {
+        return ["screen:capture", "network:false"];
+    }
+    if (operation === "write" || operation === "create_file" || operation === "write_if_unchanged" || operation === "edit" || operation === "patch" || operation === "mkdir" || operation === "delete" || operation === "move") {
+        return ["fs:write", "network:false"];
+    }
+    return ["fs:read", "network:false"];
+}
+function gitOperationCapabilities(operation) {
+    if (operation === "git_stage" || operation === "git_unstage" || operation === "git_commit" || operation === "git_worktree_create") {
+        return ["git:write", "fs:write", "network:false"];
+    }
+    return ["git:read", "fs:read", "network:false"];
+}
+function codexOperationCapabilities(operation) {
+    if (operation === "codex_plan" || operation === "codex_review" || operation === "codex_test" || operation === "codex_runs") {
+        return ["codex:readOnly", "process:manage", "network:false"];
+    }
+    return ["codex:write", "process:manage", "network:false"];
+}
+function operationLimits(operation) {
+    if (operation === "batch")
+        return { maxBatchOperations: DEFAULT_LIMITS.maxBatchOperations };
+    if (operation === "find_files" || operation === "search_text" || operation === "search_symbols" || operation === "history" || operation === "history_insight")
+        return { maxSearchResults: DEFAULT_LIMITS.maxSearchResults };
+    if (operation === "read" || operation === "read_many" || operation === "git_diff" || operation === "git_show" || operation === "repo_status")
+        return { maxFileBytes: DEFAULT_LIMITS.maxFileBytes };
+    if (operation === "command" || operation === "process_start" || operation === "package_run" || operation === "package_start" || operation === "codex" || operation === "codex_start" || operation === "codex_plan" || operation === "codex_review" || operation === "codex_fix" || operation === "codex_test" || operation === "codex_continue") {
+        return { maxRuntimeSeconds: DEFAULT_LIMITS.maxRuntimeSeconds };
+    }
+    return {};
+}

package/dist/chatgpt.d.ts

@@ -0,0 +1,167 @@
+import { type TunnelProcessSnapshot } from "./tunnels.js";
+import type { ChatGptProfileMode } from "./profile.js";
+import type { LocalPortConfig } from "./permissions.js";
+export type ChatGptVerifyMode = ChatGptProfileMode;
+export type ChatGptVerifyStatus = "pass" | "warn" | "fail";
+export type ChatGptSetupWizardStatus = "ready" | "needs_action" | "blocked";
+export type ChatGptSetupWizardStepStatus = "complete" | "current" | "blocked" | "pending";
+export interface ChatGptVerifyCheck {
+    id: string;
+    status: ChatGptVerifyStatus;
+    message: string;
+    detail?: string;
+}
+export interface ChatGptVerifyReport {
+    kind: "chatgpt-verify";
+    schemaVersion: 1;
+    mode: ChatGptVerifyMode;
+    ready: boolean;
+    mcpServerUrl: string;
+    publicBaseUrl: string | null;
+    authMode: "loopback-only" | "owner-token-or-oauth";
+    tools: string[];
+    checks: ChatGptVerifyCheck[];
+    blockingReasons: string[];
+    warnings: string[];
+    nextActions: string[];
+    recommendedProfileCommand: string;
+    recommendedSmokeTest: string[];
+}
+export interface ChatGptUrlReport {
+    kind: "chatgpt-url";
+    schemaVersion: 1;
+    ready: boolean;
+    mcpServerUrl: string | null;
+    publicBaseUrl: string | null;
+    publicBaseUrlSource: "configured" | "running-tunnel" | null;
+    configuredPublicBaseUrl: string | null;
+    detectedPublicUrl: string | null;
+    authHeader: string;
+    warnings: string[];
+    nextActions: string[];
+}
+export interface ChatGptUrlOptions {
+    tunnels?: TunnelProcessSnapshot[];
+}
+export interface ChatGptSmokeCheck {
+    id: string;
+    status: ChatGptVerifyStatus;
+    message: string;
+    url?: string;
+    statusCode?: number;
+    detail?: string;
+    durationMs?: number;
+}
+export interface ChatGptSmokeReport {
+    kind: "chatgpt-smoke";
+    schemaVersion: 1;
+    ready: boolean;
+    baseUrl: string | null;
+    mcpServerUrl: string | null;
+    authHeader: string;
+    checks: ChatGptSmokeCheck[];
+    blockingReasons: string[];
+    warnings: string[];
+    nextActions: string[];
+}
+export interface ChatGptSetupWizardStep {
+    id: "owner_token" | "public_url" | "mcp_url" | "oauth" | "workspace" | "ready";
+    label: string;
+    status: ChatGptSetupWizardStepStatus;
+    detail: string;
+    action?: string;
+}
+export interface ChatGptSetupWizard {
+    overallStatus: ChatGptSetupWizardStatus;
+    currentStepId: ChatGptSetupWizardStep["id"] | null;
+    effectiveMcpServerUrl: string | null;
+    detectedPublicUrl: string | null;
+    steps: ChatGptSetupWizardStep[];
+}
+export interface ChatGptSetupConnectProfile {
+    appName: string;
+    mode: ChatGptVerifyMode;
+    connectionType: "Remote MCP";
+    serverUrl: string;
+    auth: {
+        type: "oauth-or-bearer";
+        bearerHeader: string | null;
+        bearerTokenValue: "<ownerToken>" | null;
+        bearerTokenSource: "owner-token-config" | null;
+        oauthEnabled: boolean;
+        oauthScopes: string[];
+        oauthAuthorizationServerMetadataUrl: string | null;
+        oauthProtectedResourceMetadataUrl: string | null;
+    };
+    ready: boolean;
+    blockingReasons: string[];
+    warnings: string[];
+    nextActions: string[];
+    firstPrompt: string;
+    cli: {
+        verify: string;
+        profile: string;
+        manifest: string;
+        connectorConfig: string;
+        files: string;
+        localSmoke: string;
+        publicSmoke: string | null;
+    };
+}
+export interface ChatGptSetupStatus {
+    kind: "chatgpt-setup-status";
+    schemaVersion: 1;
+    mode: ChatGptVerifyMode;
+    ready: boolean;
+    mcpServerUrl: string;
+    publicBaseUrl: string | null;
+    authMode: "loopback-only" | "owner-token-or-oauth";
+    setupFields: {
+        appName: string;
+        connectionType: "Remote MCP";
+        mcpServerUrl: string;
+        authType: "oauth-or-bearer";
+        bearerHeader: string | null;
+        alternateBearerHeader: string | null;
+    };
+    oauthDiscovery: {
+        enabled: boolean;
+        issuer: string | null;
+        authorizationServerMetadataUrl: string | null;
+        protectedResourceMetadataUrl: string | null;
+        resource: string | null;
+        scopes: string[];
+    };
+    smoke: {
+        localCli: string;
+        publicCli: string | null;
+    };
+    cli: ChatGptSetupConnectProfile["cli"];
+    connectProfile: ChatGptSetupConnectProfile;
+    checks: ChatGptVerifyCheck[];
+    blockingReasons: string[];
+    warnings: string[];
+    nextActions: string[];
+    wizard: ChatGptSetupWizard;
+}
+export interface ChatGptSetupStatusOptions {
+    tunnels?: TunnelProcessSnapshot[];
+}
+export interface ChatGptSmokeOptions {
+    url?: string;
+    token?: string;
+    includeSecret?: boolean;
+    allowHttp?: boolean;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+export declare function chatGptVerify(config: LocalPortConfig, mode?: ChatGptVerifyMode): ChatGptVerifyReport;
+export declare function chatGptSetupStatus(config: LocalPortConfig, mode?: ChatGptVerifyMode, options?: ChatGptSetupStatusOptions): ChatGptSetupStatus;
+export declare function parseChatGptVerifyMode(value: string | undefined): ChatGptVerifyMode;
+export declare function chatGptPublicBaseUrl(config: Pick<LocalPortConfig, "publicBaseUrl">, tunnels?: TunnelProcessSnapshot[]): string | undefined;
+export declare function chatGptMcpServerUrl(config: Pick<LocalPortConfig, "publicBaseUrl">, tunnels?: TunnelProcessSnapshot[]): string | undefined;
+export declare function chatGptUrl(config: LocalPortConfig, includeSecret?: boolean, options?: ChatGptUrlOptions): ChatGptUrlReport;
+export declare function formatChatGptUrl(report: ChatGptUrlReport): string;
+export declare function chatGptSmoke(config: LocalPortConfig, options?: ChatGptSmokeOptions): Promise<ChatGptSmokeReport>;
+export declare function formatChatGptSmoke(report: ChatGptSmokeReport): string;
+export declare function formatChatGptVerify(report: ChatGptVerifyReport): string;