@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/opencode/options.d.ts

@@ -0,0 +1,156 @@
+import type { ToolPolicy } from "@camerontaylor/paseo-protocol/agent-types";
+import { z } from "zod";
+export declare const OpenCodeProviderOptionsSchema: z.ZodObject<{
+    permission: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        ask: "ask";
+    }>, z.ZodObject<{
+        read: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        edit: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        glob: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        grep: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        list: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        bash: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        task: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        external_directory: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        todowrite: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        question: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        webfetch: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        websearch: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        codesearch: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        repo_clone: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        repo_overview: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        lsp: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+        doom_loop: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        skill: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>]>>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export type OpenCodeProviderOptions = z.infer<typeof OpenCodeProviderOptionsSchema>;
+export interface OpenCodePermissionRule {
+    permission: string;
+    pattern: string;
+    action: "ask" | "allow" | "deny";
+}
+export declare function buildOpenCodePermissionRules(options: OpenCodeProviderOptions | undefined, toolPolicy: ToolPolicy | undefined): OpenCodePermissionRule[] | undefined;
+//# sourceMappingURL=options.d.ts.map

package/dist/server/server/agent/providers/opencode/options.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+const PermissionActionSchema = z.enum(["ask", "allow", "deny"]);
+const PermissionRuleSchema = z.union([
+    PermissionActionSchema,
+    z.record(z.string(), PermissionActionSchema),
+]);
+// OpenCode Config.permission, maintained against @opencode-ai/sdk 1.14.46.
+export const OpenCodeProviderOptionsSchema = z
+    .object({
+    permission: z
+        .union([
+        PermissionActionSchema,
+        z
+            .object({
+            read: PermissionRuleSchema.optional(),
+            edit: PermissionRuleSchema.optional(),
+            glob: PermissionRuleSchema.optional(),
+            grep: PermissionRuleSchema.optional(),
+            list: PermissionRuleSchema.optional(),
+            bash: PermissionRuleSchema.optional(),
+            task: PermissionRuleSchema.optional(),
+            external_directory: PermissionRuleSchema.optional(),
+            todowrite: PermissionActionSchema.optional(),
+            question: PermissionActionSchema.optional(),
+            webfetch: PermissionActionSchema.optional(),
+            websearch: PermissionActionSchema.optional(),
+            codesearch: PermissionActionSchema.optional(),
+            repo_clone: PermissionRuleSchema.optional(),
+            repo_overview: PermissionRuleSchema.optional(),
+            lsp: PermissionRuleSchema.optional(),
+            doom_loop: PermissionActionSchema.optional(),
+            skill: PermissionRuleSchema.optional(),
+        })
+            .strict(),
+    ])
+        .optional(),
+})
+    .strict();
+export function buildOpenCodePermissionRules(options, toolPolicy) {
+    const grants = toolPolicy?.preapproved.map((grant) => ({
+        permission: `${grant.server}_${grant.tool}`,
+        pattern: "*",
+        action: "allow",
+    })) ?? [];
+    const permission = options?.permission;
+    if (typeof permission === "string") {
+        return [...grants, { permission: "*", pattern: "*", action: permission }];
+    }
+    if (!permission || typeof permission !== "object" || Array.isArray(permission)) {
+        return grants.length > 0 ? grants : undefined;
+    }
+    const authored = Object.entries(permission).flatMap(([name, rule]) => {
+        if (typeof rule === "string") {
+            return [{ permission: name, pattern: "*", action: rule }];
+        }
+        if (!rule || typeof rule !== "object" || Array.isArray(rule))
+            return [];
+        return Object.entries(rule).flatMap(([pattern, action]) => typeof action === "string" ? [{ permission: name, pattern, action }] : []);
+    });
+    return [...grants, ...authored];
+}
+//# sourceMappingURL=options.js.map

package/dist/server/server/agent/providers/opencode/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveOpenCodeHomeDir(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/server/server/agent/providers/opencode/paths.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+import { resolvePaseoHome } from "../../../paseo-home.js";
+const OPENCODE_HOME_DIRNAME = "opencode-home";
+export function resolveOpenCodeHomeDir(env = process.env) {
+    return path.join(resolvePaseoHome(env), OPENCODE_HOME_DIRNAME);
+}
+//# sourceMappingURL=paths.js.map

package/dist/server/server/agent/providers/opencode/rewind.d.ts

@@ -0,0 +1,18 @@
+export interface OpenCodeRewindClient {
+    session: {
+        revert(input: {
+            sessionID: string;
+            directory: string;
+            messageID: string;
+        }): Promise<{
+            error?: unknown;
+        }>;
+    };
+}
+export declare function revertOpenCodeConversationAndFiles(input: {
+    client: OpenCodeRewindClient;
+    sessionId: string;
+    cwd: string;
+    messageId: string;
+}): Promise<void>;
+//# sourceMappingURL=rewind.d.ts.map

package/dist/server/server/agent/providers/opencode/rewind.js

@@ -0,0 +1,14 @@
+import { toDiagnosticErrorMessage } from "../diagnostic-utils.js";
+export async function revertOpenCodeConversationAndFiles(input) {
+    // OpenCode keeps unrevert available only until a later prompt triggers its cleanup,
+    // which permanently drops reverted messages. Paseo v1 only exposes revert.
+    const response = await input.client.session.revert({
+        sessionID: input.sessionId,
+        directory: input.cwd,
+        messageID: input.messageId,
+    });
+    if (response.error) {
+        throw new Error(toDiagnosticErrorMessage(response.error));
+    }
+}
+//# sourceMappingURL=rewind.js.map

package/dist/server/server/agent/providers/opencode/server-manager.d.ts

@@ -0,0 +1,101 @@
+import type { ChildProcess } from "node:child_process";
+import type { Logger } from "pino";
+import { type SpawnProcessOptions } from "../../../../utils/spawn.js";
+import { type ProcessTerminator } from "../../../../utils/tree-kill.js";
+import type { ManagedProcessRegistry } from "../../../managed-processes/managed-processes.js";
+import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
+import { OpenCodeEventConsumer, type OpenCodeEventConsumerFactory, type OpenCodeEventSource } from "./event-consumer.js";
+/** Budget for the OpenCode HTTP server to become usable after spawn. */
+export declare const OPENCODE_SERVER_STARTUP_TIMEOUT_MS = 30000;
+/** One stalled SSE attempt plus enough time for the consumer's retry. */
+export declare const OPENCODE_EVENT_STREAM_READY_TIMEOUT_MS = 45000;
+export interface OpenCodeServerAcquisition {
+    server: {
+        port: number;
+        url: string;
+    };
+    events: OpenCodeEventSource;
+    release: () => Promise<void>;
+}
+export interface OpenCodeServerManagerLike {
+    acquireCurrent(signal?: AbortSignal): Promise<OpenCodeServerAcquisition>;
+    acquireNew(signal?: AbortSignal): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    acquireExisting(url: string): OpenCodeServerAcquisition | null;
+    shutdown(): Promise<void>;
+}
+export interface OpenCodeServerGeneration {
+    process: ChildProcess;
+    port: number;
+    url: string;
+    refCount: number;
+    retired: boolean;
+    ready: Promise<void>;
+    events: OpenCodeEventConsumer;
+    managedProcessId?: string;
+    managedProcessRecord?: Promise<{
+        id: string;
+    } | null>;
+}
+export type OpenCodePortAllocator = () => Promise<number>;
+export type OpenCodeCommandPrefixResolver = () => Promise<{
+    command: string;
+    args: string[];
+}>;
+export type OpenCodeServerProcessSpawner = (command: string, args: string[], options: SpawnProcessOptions) => ChildProcess;
+export interface OpenCodeServerManagerOptions {
+    logger: Logger;
+    baseEnv?: SpawnProcessOptions["baseEnv"];
+    runtimeSettings?: ProviderRuntimeSettings;
+    managedProcesses?: ManagedProcessRegistry;
+    terminateProcess?: ProcessTerminator;
+    portAllocator?: OpenCodePortAllocator;
+    resolveCommandPrefix?: OpenCodeCommandPrefixResolver;
+    resolveHomeDir?: () => string;
+    spawnServerProcess?: OpenCodeServerProcessSpawner;
+    createEventSource?: OpenCodeEventConsumerFactory;
+    decorateServerEnv?: (env: Record<string, string>) => Record<string, string>;
+}
+export declare class OpenCodeServerManager implements OpenCodeServerManagerLike {
+    private static instance;
+    private static exitHandlerRegistered;
+    private currentServer;
+    private retiredServers;
+    private startPromise;
+    private newServerPromise;
+    private readonly logger;
+    private readonly baseEnv?;
+    private readonly runtimeSettings?;
+    private readonly runtimeSettingsKey;
+    private readonly managedProcesses?;
+    private readonly terminateProcess;
+    private readonly portAllocator;
+    private readonly resolveCommandPrefix;
+    private readonly resolveHomeDir;
+    private readonly spawnServerProcess;
+    private readonly createEventSource;
+    private readonly decorateServerEnv?;
+    constructor(options: OpenCodeServerManagerOptions);
+    static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings, options?: Omit<OpenCodeServerManagerOptions, "logger" | "runtimeSettings">): OpenCodeServerManager;
+    private static registerExitHandler;
+    acquireCurrent(signal?: AbortSignal): Promise<OpenCodeServerAcquisition>;
+    acquireNew(signal?: AbortSignal): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    acquireExisting(url: string): OpenCodeServerAcquisition | null;
+    private findLiveServerByUrl;
+    private isServerLive;
+    private acquireServer;
+    private releaseServer;
+    private getNewServer;
+    private getCurrentServer;
+    private rotateCurrentServer;
+    private startServer;
+    shutdown(): Promise<void>;
+    private cleanupRetiredServers;
+    private killServer;
+    private recordManagedServerProcess;
+    private removeManagedProcessRecordWhenResolved;
+    private removeManagedServerRecord;
+    private removeManagedProcessId;
+}
+//# sourceMappingURL=server-manager.d.ts.map