@agentex/agent 0.0.27 → 0.0.28

package/src/providers/opencode/manager.ts

@@ -0,0 +1,269 @@
+import { createHash, randomUUID } from "node:crypto";
+import type {
+  ProviderAuthFlow,
+  ProviderAuthMethod,
+  ProviderRuntimeContext,
+  UpstreamProvider,
+  UpstreamProviderManager,
+} from "../../types.js";
+import type { OpenCodeServerHandle } from "./server.js";
+import { acquireOpenCodeRuntime } from "./runtime.js";
+
+const FLOW_TTL_MS = 10 * 60 * 1000;
+const MAX_FLOWS = 128;
+
+interface FlowRecord {
+  id: string;
+  providerId: string;
+  methodIndex: number;
+  expiresAt: number;
+  completion: "code" | "automatic";
+  server: OpenCodeServerHandle;
+  contextKey: string;
+  expiryTimer: ReturnType<typeof setTimeout>;
+}
+
+const flows = new Map<string, FlowRecord>();
+
+export class OpenCodeDisconnectUnsupportedError extends Error {
+  readonly code = "disconnect_unsupported";
+  constructor() {
+    super("The selected OpenCode protocol profile cannot safely remove this credential");
+    this.name = "OpenCodeDisconnectUnsupportedError";
+  }
+}
+
+export class OpenCodeAuthFlowExpiredError extends Error {
+  readonly code = "auth_flow_expired_or_restarted";
+  constructor() {
+    super("The OpenCode authentication flow expired or the process restarted");
+    this.name = "OpenCodeAuthFlowExpiredError";
+  }
+}
+
+function rec(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+function stableMethodId(providerId: string, index: number, method: Record<string, unknown>): string {
+  const hash = createHash("sha256")
+    .update(`${providerId}\0${method["type"] ?? ""}\0${method["label"] ?? ""}\0${index}`)
+    .digest("hex")
+    .slice(0, 16);
+  return `ocm_${hash}`;
+}
+
+function safeMethod(providerId: string, index: number, value: unknown): ProviderAuthMethod {
+  const method = rec(value);
+  const prompts = Array.isArray(method["prompts"])
+    ? method["prompts"].map((raw) => {
+        const prompt = rec(raw);
+        const type = prompt["type"] === "select" ? "select" as const : "text" as const;
+        return {
+          id: typeof prompt["key"] === "string" ? prompt["key"] : "input",
+          label: typeof prompt["message"] === "string" ? prompt["message"] : "Input",
+          type,
+          ...(type === "select" && Array.isArray(prompt["options"])
+            ? { options: prompt["options"].map((item) => {
+                const option = rec(item);
+                return {
+                  value: typeof option["value"] === "string" ? option["value"] : "",
+                  label: typeof option["label"] === "string" ? option["label"] : "",
+                };
+              }).filter((item) => item.value) }
+            : {}),
+        };
+      })
+    : undefined;
+  return {
+    id: stableMethodId(providerId, index, method),
+    name: typeof method["label"] === "string" ? method["label"] : "Authentication",
+    type: method["type"] === "oauth" ? "oauth" : "api_key",
+    ...(prompts?.length ? { prompts } : {}),
+  };
+}
+
+function contextKey(ctx: ProviderRuntimeContext): string {
+  return JSON.stringify({ cwd: ctx.cwd ?? process.cwd(), command: ctx.config?.command ?? null });
+}
+
+function cleanupFlows(): void {
+  const now = Date.now();
+  for (const [id, flow] of flows) {
+    if (flow.expiresAt <= now) {
+      clearTimeout(flow.expiryTimer);
+      flow.server.release();
+      flows.delete(id);
+    }
+  }
+  while (flows.size >= MAX_FLOWS) {
+    const oldest = flows.keys().next().value as string | undefined;
+    if (!oldest) break;
+    const flow = flows.get(oldest);
+    if (flow) {
+      clearTimeout(flow.expiryTimer);
+      flow.server.release();
+    }
+    flows.delete(oldest);
+  }
+}
+
+async function authPayload(ctx: ProviderRuntimeContext) {
+  const runtime = await acquireOpenCodeRuntime(ctx);
+  const payload = await runtime.server.client.json<Record<string, unknown>>("/provider/auth");
+  return { runtime, payload };
+}
+
+async function methodIndex(providerId: string, methodId: string, ctx: ProviderRuntimeContext) {
+  const { runtime, payload } = await authPayload(ctx);
+  const methods = Array.isArray(payload[providerId]) ? payload[providerId] : [];
+  const index = methods.findIndex((method, candidate) => stableMethodId(providerId, candidate, rec(method)) === methodId);
+  if (index < 0) {
+    runtime.server.release();
+    throw new Error("OpenCode authentication method is unavailable");
+  }
+  return { runtime, index };
+}
+
+async function supportsProviderDelete(ctx: ProviderRuntimeContext): Promise<boolean> {
+  const runtime = await acquireOpenCodeRuntime(ctx);
+  try {
+    const doc = await runtime.server.client.json<Record<string, unknown>>("/doc");
+    const paths = rec(doc["paths"]);
+    const route = rec(paths["/auth/{providerID}"]);
+    return Boolean(route["delete"]);
+  } finally {
+    runtime.server.release();
+  }
+}
+
+export const openCodeUpstreamProviders: UpstreamProviderManager = {
+  async list(ctx = {}): Promise<UpstreamProvider[]> {
+    const runtime = await acquireOpenCodeRuntime(ctx);
+    try {
+      const [providers, methods] = await Promise.all([
+        runtime.server.client.json<Record<string, unknown>>("/provider"),
+        runtime.server.client.json<Record<string, unknown>>("/provider/auth"),
+      ]);
+      const connected = new Set(Array.isArray(providers["connected"])
+        ? providers["connected"].filter((item): item is string => typeof item === "string")
+        : []);
+      return (Array.isArray(providers["all"]) ? providers["all"] : []).map((raw) => {
+        const provider = rec(raw);
+        const id = typeof provider["id"] === "string" ? provider["id"] : "";
+        const auth = Array.isArray(methods[id]) ? methods[id] : [];
+        return {
+          id,
+          name: typeof provider["name"] === "string" ? provider["name"] : id,
+          connected: connected.has(id),
+          authMethodIds: auth.map((method, index) => stableMethodId(id, index, rec(method))),
+        };
+      }).filter((provider) => provider.id);
+    } finally {
+      runtime.server.release();
+    }
+  },
+
+  async authMethods(providerId, ctx = {}) {
+    const { runtime, payload } = await authPayload(ctx);
+    try {
+      const methods = Array.isArray(payload[providerId]) ? payload[providerId] : [];
+      return methods.map((method, index) => safeMethod(providerId, index, method));
+    } finally {
+      runtime.server.release();
+    }
+  },
+
+  async setApiKey(providerId, key, ctx = {}) {
+    if (!key.trim()) throw new Error("OpenCode API key must not be empty");
+    const runtime = await acquireOpenCodeRuntime(ctx);
+    try {
+      await runtime.server.client.ok(`/auth/${encodeURIComponent(providerId)}`, {
+        method: "PUT",
+        body: JSON.stringify({ type: "api", key }),
+      });
+      await runtime.server.retireAuthStore();
+    } finally {
+      runtime.server.release();
+    }
+  },
+
+  async beginOAuth(providerId, methodId, inputs, ctx = {}) {
+    cleanupFlows();
+    const { runtime, index } = await methodIndex(providerId, methodId, ctx);
+    try {
+      const response = await runtime.server.client.json<Record<string, unknown>>(
+        `/provider/${encodeURIComponent(providerId)}/oauth/authorize`,
+        { method: "POST", body: JSON.stringify({ method: index, ...(inputs ? { inputs } : {}) }) },
+      );
+      const id = `ocf_${randomUUID()}`;
+      const expiresAt = Date.now() + FLOW_TTL_MS;
+      const completion = response["method"] === "auto" ? "automatic" : "code";
+      const expiryTimer = setTimeout(() => {
+        const expired = flows.get(id);
+        if (!expired) return;
+        flows.delete(id);
+        expired.server.release();
+      }, FLOW_TTL_MS);
+      expiryTimer.unref();
+      flows.set(id, {
+        id,
+        providerId,
+        methodIndex: index,
+        expiresAt,
+        completion,
+        server: runtime.server,
+        contextKey: contextKey(ctx),
+        expiryTimer,
+      });
+      return {
+        id,
+        providerId,
+        url: typeof response["url"] === "string" ? response["url"] : null,
+        completion,
+        instructions: typeof response["instructions"] === "string" ? response["instructions"] : null,
+        expiresAt: new Date(expiresAt).toISOString(),
+      } satisfies ProviderAuthFlow;
+    } catch (error) {
+      runtime.server.release();
+      throw error;
+    }
+  },
+
+  async completeOAuth(flowId, code, ctx = {}) {
+    cleanupFlows();
+    const flow = flows.get(flowId);
+    if (!flow || flow.expiresAt <= Date.now() || flow.contextKey !== contextKey(ctx)) {
+      throw new OpenCodeAuthFlowExpiredError();
+    }
+    flows.delete(flowId);
+    clearTimeout(flow.expiryTimer);
+    try {
+      await flow.server.client.ok(`/provider/${encodeURIComponent(flow.providerId)}/oauth/callback`, {
+        method: "POST",
+        body: JSON.stringify({ method: flow.methodIndex, ...(code ? { code } : {}) }),
+      });
+      await flow.server.retireAuthStore();
+    } finally {
+      flow.server.release();
+    }
+  },
+
+  canDisconnect(providerId, ctx = {}) {
+    void providerId;
+    return supportsProviderDelete(ctx);
+  },
+
+  async disconnect(providerId, ctx = {}) {
+    if (!await supportsProviderDelete(ctx)) throw new OpenCodeDisconnectUnsupportedError();
+    const runtime = await acquireOpenCodeRuntime(ctx);
+    try {
+      await runtime.server.client.ok(`/auth/${encodeURIComponent(providerId)}`, { method: "DELETE" });
+      await runtime.server.retireAuthStore({ force: true });
+    } finally {
+      runtime.server.release();
+    }
+  },
+};

package/src/providers/opencode/modes.ts

@@ -0,0 +1,31 @@
+import type { AgentMode, ListModesOptions } from "../../types.js";
+import { acquireOpenCodeRuntime } from "./runtime.js";
+
+function rec(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+export async function listOpenCodeModes(options: ListModesOptions = {}): Promise<AgentMode[]> {
+  const runtime = await acquireOpenCodeRuntime(options);
+  try {
+    const payload = await runtime.server.client.json<unknown[]>("/agent");
+    return (Array.isArray(payload) ? payload : []).map((raw) => {
+      const agent = rec(raw);
+      const id = typeof agent["name"] === "string"
+        ? agent["name"]
+        : typeof agent["id"] === "string" ? agent["id"] : "";
+      const mode = typeof agent["mode"] === "string" ? agent["mode"] : "primary";
+      return {
+        id,
+        name: typeof agent["label"] === "string" ? agent["label"] : id,
+        description: typeof agent["description"] === "string" ? agent["description"] : undefined,
+        mode,
+      };
+    }).filter((agent) => agent.id && agent.mode !== "subagent")
+      .map(({ mode: _mode, ...agent }) => agent);
+  } finally {
+    runtime.server.release();
+  }
+}

package/src/providers/opencode/parse.ts

@@ -159,31 +159,11 @@ export function parseOpenCodeStreamLine(line: string): StreamEvent | null {
   }
 
   if (type === "step_finish") {
-    return {
-      type: "result",
-      text: "",
-      costUsd: null,
-      isError: false,
-      stopReason: null,
-      terminalReason: null,
-      numTurns: null,
-      durationMs: null,
-      ...base,
-    };
+    return { type: "unknown", subtype: "step_finish", ...base };
   }
 
   if (type === "error") {
-    return {
-      type: "result",
-      text: asString(event["message"], ""),
-      costUsd: null,
-      isError: true,
-      stopReason: null,
-      terminalReason: null,
-      numTurns: null,
-      durationMs: null,
-      ...base,
-    };
+    return { type: "unknown", subtype: "error", ...base };
   }
 
   // Forward-compat: surface unknown wire events rather than dropping them.

package/src/providers/opencode/probe.ts

@@ -0,0 +1,113 @@
+import type { ProviderRuntimeContext, ProviderRuntimeReport } from "../../types.js";
+import { findBinary } from "../../utils/binary.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { runChildProcess } from "../../utils/process.js";
+import { acquireOpenCodeRuntime } from "./runtime.js";
+
+function rec(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+function capability(
+  supported: boolean,
+  reason?: string,
+): { supported: boolean; status: "supported" | "upgrade_required"; reason?: string } {
+  return {
+    supported,
+    status: supported ? "supported" : "upgrade_required",
+    ...(reason ? { reason } : {}),
+  };
+}
+
+export async function probeOpenCodeCapabilities(
+  ctx: ProviderRuntimeContext = {},
+): Promise<ProviderRuntimeReport> {
+  let resolved;
+  try {
+    resolved = await findBinary("opencode", ctx.config?.command);
+  } catch (error) {
+    return {
+      binary: {
+        status: "missing",
+        command: null,
+        version: null,
+        protocolProfile: null,
+        reason: error instanceof Error ? error.message : String(error),
+      },
+      capabilities: {},
+    };
+  }
+
+  const env = buildEnv(ctx.env);
+  ensurePathInEnv(env);
+  let version: string | null = null;
+  try {
+    const result = await runChildProcess({
+      runId: "opencode-version-probe",
+      command: resolved.bin,
+      args: [...resolved.prefixArgs, "--version"],
+      cwd: ctx.cwd ?? process.cwd(),
+      env,
+      timeoutSec: 5,
+    });
+    version = (result.stdout || result.stderr).match(/\d+\.\d+(?:\.\d+)?/)?.[0] ?? null;
+  } catch {
+    // The authenticated API probe below remains authoritative.
+  }
+
+  try {
+    const runtime = await acquireOpenCodeRuntime(ctx);
+    try {
+      const doc = await runtime.server.client.json<Record<string, unknown>>("/doc");
+      const agents = await runtime.server.client.json<unknown[]>("/agent").catch(() => []);
+      const paths = rec(doc["paths"]);
+      const has = (path: string, method: string) => Boolean(rec(paths[path])[method]);
+      const supportsDisconnect = has("/auth/{providerID}", "delete");
+      const capabilities: ProviderRuntimeReport["capabilities"] = {
+        sessions: capability(has("/session", "post") && has("/session/{sessionID}/message", "post")),
+        resume: capability(has("/session/{sessionID}", "get")),
+        modelDiscovery: capability(has("/provider", "get")),
+        modelVariants: capability(has("/provider", "get")),
+        permissionRequests: capability(has("/permission", "get") && has("/permission/{requestID}/reply", "post")),
+        questionRequests: capability(has("/question", "get") && has("/question/{requestID}/reply", "post")),
+        upstreamProviderDisconnect: capability(supportsDisconnect),
+        durableHistory: capability(has("/session/{sessionID}/message", "get")),
+        planMode: capability(agents.some((value) => {
+          const agent = rec(value);
+          return agent["name"] === "plan" || agent["id"] === "plan";
+        })),
+        modes: capability(agents.length > 0),
+        sessionModelChange: capability(true),
+        sessionVariantChange: capability(true),
+        sessionModeChange: capability(agents.length > 0),
+      };
+      const required = ["sessions", "modelDiscovery", "permissionRequests", "questionRequests"] as const;
+      const degraded = required.some((key) => !capabilities[key]?.supported);
+      return {
+        binary: {
+          status: degraded ? "degraded" : "supported",
+          command: resolved.bin,
+          version,
+          protocolProfile: supportsDisconnect ? "opencode-server-auth-v1" : "opencode-server-v1",
+          ...(degraded ? { reason: "The OpenCode server schema is missing a required endpoint" } : {}),
+        },
+        capabilities,
+      };
+    } finally {
+      runtime.server.release();
+    }
+  } catch (error) {
+    return {
+      binary: {
+        status: "degraded",
+        command: resolved.bin,
+        version,
+        protocolProfile: null,
+        reason: error instanceof Error ? error.message : String(error),
+      },
+      capabilities: {},
+    };
+  }
+}

package/src/providers/opencode/runtime.ts

@@ -0,0 +1,13 @@
+import type { ProviderRuntimeContext } from "../../types.js";
+import { findBinary } from "../../utils/binary.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { acquireOpenCodeServer } from "./server.js";
+
+export async function acquireOpenCodeRuntime(ctx: ProviderRuntimeContext = {}) {
+  const resolved = await findBinary("opencode", ctx.config?.command);
+  const env = buildEnv(ctx.env);
+  ensurePathInEnv(env);
+  const cwd = ctx.cwd ?? process.cwd();
+  const server = await acquireOpenCodeServer(resolved.bin, resolved.prefixArgs, env, cwd);
+  return { resolved, env, cwd, server };
+}

package/src/providers/opencode/skill-config.ts

@@ -0,0 +1,64 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export interface OpenCodeSkillConfig {
+  env: Record<string, string>;
+  cleanup(): Promise<void>;
+}
+
+function sourceConfigDir(env: Record<string, string>): string {
+  if (env["OPENCODE_CONFIG_DIR"]) return env["OPENCODE_CONFIG_DIR"];
+  const configHome = env["XDG_CONFIG_HOME"]
+    ?? path.join(env["HOME"] ?? os.homedir(), ".config");
+  return path.join(configHome, "opencode");
+}
+
+/**
+ * Build an isolated OpenCode config directory containing requested skills.
+ * Existing global config is copied first, so config precedence is preserved
+ * without writing into the user's home or workspace.
+ */
+export async function prepareOpenCodeSkillConfig(
+  env: Record<string, string>,
+  skillDirs: string[] | undefined,
+): Promise<OpenCodeSkillConfig> {
+  if (!skillDirs?.length) return { env, cleanup: async () => {} };
+
+  const configDir = await fs.mkdtemp(path.join(os.tmpdir(), "agentex-opencode-"));
+  try {
+    await fs.cp(sourceConfigDir(env), configDir, {
+      recursive: true,
+      force: false,
+      errorOnExist: false,
+    });
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code !== "ENOENT") {
+      await fs.rm(configDir, { recursive: true, force: true });
+      throw error;
+    }
+  }
+
+  try {
+    const skillsDir = path.join(configDir, "skills");
+    await fs.mkdir(skillsDir, { recursive: true });
+    for (const directory of skillDirs) {
+      const source = path.resolve(directory);
+      const name = path.basename(source);
+      const stat = await fs.stat(path.join(source, "SKILL.md"));
+      if (!stat.isFile()) throw new Error(`OpenCode skill has no SKILL.md: ${source}`);
+      const target = path.join(skillsDir, name);
+      await fs.rm(target, { recursive: true, force: true });
+      await fs.symlink(source, target, process.platform === "win32" ? "junction" : "dir");
+    }
+  } catch (error) {
+    await fs.rm(configDir, { recursive: true, force: true });
+    throw error;
+  }
+
+  return {
+    env: { ...env, OPENCODE_CONFIG_DIR: configDir },
+    cleanup: () => fs.rm(configDir, { recursive: true, force: true }),
+  };
+}