opencode-gateway 0.2.9 → 0.2.10

package/README.md

@@ -28,10 +28,22 @@ Check what it resolved:
 npx opencode-gateway doctor
 ```
 
-Then start OpenCode normally:
+Recommended:
+
+```bash
+opencode-gateway serve
+```
+
+This wraps `opencode serve` and warms the gateway plugin worker immediately, so
+Telegram polling and scheduled jobs do not stay idle until the first
+project-scoped request.
+
+If you still prefer the raw OpenCode command, warm the gateway explicitly after
+startup:
 
 ```bash
 opencode serve
+opencode-gateway warm
 ```
 
 If you want a separate managed config tree instead of editing your existing
@@ -39,9 +51,7 @@ OpenCode config:
 
 ```bash
 npx opencode-gateway init --managed
-export OPENCODE_CONFIG="$HOME/.config/opencode-gateway/opencode/opencode.json"
-export OPENCODE_CONFIG_DIR="$HOME/.config/opencode-gateway/opencode"
-opencode serve
+opencode-gateway serve --managed
 ```
 
 ## Example gateway config

package/dist/cli/args.d.ts

@@ -1,7 +1,7 @@
 export type CliCommand = {
     kind: "help";
 } | {
-    kind: "init" | "doctor";
+    kind: "init" | "doctor" | "serve" | "warm";
     managed: boolean;
     configDir: string | null;
 };

package/dist/cli/opencode-server.d.ts

@@ -0,0 +1,19 @@
+type CliOptions = {
+    managed: boolean;
+    configDir: string | null;
+};
+export type ResolvedServeTarget = {
+    configDir: string;
+    gatewayConfigPath: string;
+    workspaceDirPath: string;
+    opencodeConfigPath: string;
+    serverOrigin: string;
+    env: Record<string, string>;
+};
+export declare function resolveServeTarget(options: CliOptions, env: Record<string, string | undefined>): Promise<ResolvedServeTarget>;
+export declare function warmGatewayProject(target: ResolvedServeTarget, options?: {
+    deadlineMs?: number;
+    intervalMs?: number;
+}): Promise<void>;
+export declare function resolveServerOriginFromDocument(document: Record<string, unknown>): string;
+export {};

package/dist/cli/serve.d.ts

@@ -0,0 +1,6 @@
+type ServeOptions = {
+    managed: boolean;
+    configDir: string | null;
+};
+export declare function runServe(options: ServeOptions, env: Record<string, string | undefined>): Promise<void>;
+export {};

package/dist/cli/warm.d.ts

@@ -0,0 +1,6 @@
+type WarmOptions = {
+    managed: boolean;
+    configDir: string | null;
+};
+export declare function runWarm(options: WarmOptions, env: Record<string, string | undefined>): Promise<void>;
+export {};

package/dist/cli.js

@@ -7,7 +7,7 @@ function parseCliCommand(argv) {
   if (!command || command === "help" || command === "--help" || command === "-h") {
     return { kind: "help" };
   }
-  if (command !== "init" && command !== "doctor") {
+  if (command !== "init" && command !== "doctor" && command !== "serve" && command !== "warm") {
     throw new Error(`unknown command: ${command}`);
   }
   let managed = false;
@@ -48,6 +48,8 @@ function formatCliHelp() {
     "Commands:",
     "  opencode-gateway init [--managed] [--config-dir <path>]",
     "  opencode-gateway doctor [--managed] [--config-dir <path>]",
+    "  opencode-gateway warm [--managed] [--config-dir <path>]",
+    "  opencode-gateway serve [--managed] [--config-dir <path>]",
     "",
     "Defaults:",
     "  init/doctor use OPENCODE_CONFIG_DIR when set, otherwise ~/.config/opencode",
@@ -57,42 +59,7 @@ function formatCliHelp() {
 }
 
 // src/cli/doctor.ts
-import { readFile } from "node:fs/promises";
-import { join as join3 } from "node:path";
-
-// src/config/paths.ts
-import { homedir } from "node:os";
-import { dirname, join, resolve as resolve2 } from "node:path";
-var GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
-var OPENCODE_CONFIG_FILE = "opencode.json";
-var OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
-var OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
-var GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
-function resolveOpencodeConfigDir(env) {
-  const explicit = env.OPENCODE_CONFIG_DIR;
-  if (explicit && explicit.trim().length > 0) {
-    return resolve2(explicit);
-  }
-  return defaultOpencodeConfigDir(env);
-}
-function resolveManagedOpencodeConfigDir(env) {
-  return join(resolveConfigHome(env), "opencode-gateway", "opencode");
-}
-function resolveGatewayWorkspacePath(configPath) {
-  return join(dirname(configPath), GATEWAY_WORKSPACE_DIR);
-}
-function defaultGatewayStateDbPath(env) {
-  return join(resolveDataHome(env), "opencode-gateway", "state.db");
-}
-function resolveConfigHome(env) {
-  return env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-}
-function resolveDataHome(env) {
-  return env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-}
-function defaultOpencodeConfigDir(env) {
-  return join(resolveConfigHome(env), "opencode");
-}
+import { readFile as readFile2 } from "node:fs/promises";
 
 // src/cli/opencode-config.ts
 var OPENCODE_SCHEMA_URL = "https://opencode.ai/config.json";
@@ -290,6 +257,47 @@ function isGatewayPluginReference(entry) {
 // src/cli/opencode-config-file.ts
 import { join as join2 } from "node:path";
 
+// src/config/paths.ts
+import { homedir } from "node:os";
+import { dirname, join, resolve as resolve2 } from "node:path";
+var GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
+var OPENCODE_CONFIG_FILE = "opencode.json";
+var OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
+var OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
+var GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
+function resolveGatewayConfigPath(env) {
+  const explicit = env.OPENCODE_GATEWAY_CONFIG;
+  if (explicit && explicit.trim().length > 0) {
+    return resolve2(explicit);
+  }
+  return join(resolveOpencodeConfigDir(env), GATEWAY_CONFIG_FILE);
+}
+function resolveOpencodeConfigDir(env) {
+  const explicit = env.OPENCODE_CONFIG_DIR;
+  if (explicit && explicit.trim().length > 0) {
+    return resolve2(explicit);
+  }
+  return defaultOpencodeConfigDir(env);
+}
+function resolveManagedOpencodeConfigDir(env) {
+  return join(resolveConfigHome(env), "opencode-gateway", "opencode");
+}
+function resolveGatewayWorkspacePath(configPath) {
+  return join(dirname(configPath), GATEWAY_WORKSPACE_DIR);
+}
+function defaultGatewayStateDbPath(env) {
+  return join(resolveDataHome(env), "opencode-gateway", "state.db");
+}
+function resolveConfigHome(env) {
+  return env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+}
+function resolveDataHome(env) {
+  return env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+}
+function defaultOpencodeConfigDir(env) {
+  return join(resolveConfigHome(env), "opencode");
+}
+
 // src/cli/paths.ts
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
@@ -329,19 +337,106 @@ async function resolveOpencodeConfigFile(configDir) {
   };
 }
 
+// src/cli/opencode-server.ts
+import { readFile } from "node:fs/promises";
+var DEFAULT_SERVER_ORIGIN = "http://127.0.0.1:4096";
+var WARM_REQUEST_TIMEOUT_MS = 2000;
+async function resolveServeTarget(options, env) {
+  const configDir = resolveCliConfigDir(options, env);
+  const gatewayConfigPath = resolveGatewayConfigPath({
+    ...env,
+    OPENCODE_CONFIG_DIR: configDir
+  });
+  const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
+  const opencodeConfig = await resolveOpencodeConfigFile(configDir);
+  const serverOrigin = opencodeConfig.exists ? await resolveServerOrigin(opencodeConfig.path) : DEFAULT_SERVER_ORIGIN;
+  return {
+    configDir,
+    gatewayConfigPath,
+    workspaceDirPath,
+    opencodeConfigPath: opencodeConfig.path,
+    serverOrigin,
+    env: {
+      OPENCODE_CONFIG_DIR: configDir,
+      OPENCODE_CONFIG: opencodeConfig.path
+    }
+  };
+}
+async function warmGatewayProject(target, options) {
+  const deadlineMs = options?.deadlineMs ?? 30000;
+  const intervalMs = options?.intervalMs ?? 250;
+  const warmUrl = new URL("/experimental/tool/ids", target.serverOrigin);
+  warmUrl.searchParams.set("directory", target.workspaceDirPath);
+  const deadline = Date.now() + deadlineMs;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(warmUrl, {
+        signal: AbortSignal.timeout(WARM_REQUEST_TIMEOUT_MS)
+      });
+      if (response.ok) {
+        const payload = await response.json();
+        if (isGatewayToolList(payload)) {
+          return;
+        }
+      }
+    } catch {}
+    await delay(intervalMs);
+  }
+  throw new Error(`failed to warm the gateway plugin at ${target.serverOrigin} for ${target.workspaceDirPath}`);
+}
+function resolveServerOriginFromDocument(document) {
+  const server = document.server;
+  if (server === null || typeof server !== "object" || Array.isArray(server)) {
+    return DEFAULT_SERVER_ORIGIN;
+  }
+  const hostname = readNonEmptyString(server.hostname);
+  const port = readPort(server.port);
+  if (hostname === null || port === null) {
+    return DEFAULT_SERVER_ORIGIN;
+  }
+  return `http://${hostname}:${port}`;
+}
+async function resolveServerOrigin(configPath) {
+  const source = await readFile(configPath, "utf8");
+  const document = parseOpencodeConfig(source, configPath);
+  return resolveServerOriginFromDocument(document);
+}
+function readNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function readPort(value) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    return null;
+  }
+  return value >= 1 && value <= 65535 ? value : null;
+}
+function isGatewayToolList(value) {
+  return Array.isArray(value) && value.includes("gateway_status");
+}
+function delay(durationMs) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, durationMs);
+  });
+}
+
 // src/cli/doctor.ts
 async function runDoctor(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
-  const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
   const opencodeConfig = await resolveOpencodeConfigFile(configDir);
   const opencodeStatus = await inspectOpencodeConfig(opencodeConfig.path);
   const gatewayOverride = env.OPENCODE_GATEWAY_CONFIG?.trim() || null;
+  const serveTarget = await resolveServeTarget(options, env);
   console.log("doctor report");
   console.log(`  config dir: ${configDir}`);
   console.log(`  opencode config: ${await describePath(opencodeConfig.path)}`);
-  console.log(`  gateway config: ${await describePath(gatewayConfigPath)}`);
-  console.log(`  gateway workspace: ${await describePath(workspaceDirPath)}`);
+  console.log(`  gateway config: ${await describePath(serveTarget.gatewayConfigPath)}`);
+  console.log(`  gateway workspace: ${await describePath(serveTarget.workspaceDirPath)}`);
+  console.log(`  warm server: ${serveTarget.serverOrigin}`);
+  console.log(`  warm directory: ${serveTarget.workspaceDirPath}`);
   console.log(`  gateway config override: ${gatewayOverride ?? "not set"}`);
   console.log(`  plugin configured: ${opencodeStatus.pluginConfigured}`);
   console.log(`  TELEGRAM_BOT_TOKEN: ${env.TELEGRAM_BOT_TOKEN?.trim() ? "set" : "missing"}`);
@@ -360,7 +455,7 @@ async function inspectOpencodeConfig(path) {
     };
   }
   try {
-    const parsed = parseOpencodeConfig(await readFile(path, "utf8"), path);
+    const parsed = parseOpencodeConfig(await readFile2(path, "utf8"), path);
     return {
       pluginConfigured: inspectGatewayPlugin(parsed),
       error: null
@@ -374,8 +469,8 @@ async function inspectOpencodeConfig(path) {
 }
 
 // src/cli/init.ts
-import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
 
 // src/cli/templates.ts
 function buildGatewayConfigTemplate(stateDbPath) {
@@ -438,7 +533,7 @@ function escapeTomlString(value) {
 // src/cli/init.ts
 async function runInit(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const gatewayConfigPath = join4(configDir, GATEWAY_CONFIG_FILE);
+  const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
   const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
   const opencodeConfig = await resolveOpencodeConfigFile(configDir);
   const opencodeConfigPath = opencodeConfig.path;
@@ -449,7 +544,7 @@ async function runInit(options, env) {
     await writeFile(opencodeConfigPath, stringifyOpencodeConfig(createDefaultOpencodeConfig(options.managed)));
     opencodeStatus = "created";
   } else {
-    const source = await readFile2(opencodeConfigPath, "utf8");
+    const source = await readFile3(opencodeConfigPath, "utf8");
     const parsed = parseOpencodeConfig(source, opencodeConfigPath);
     const next = ensureGatewayPlugin(parsed);
     if (next.changed) {
@@ -467,6 +562,54 @@ async function runInit(options, env) {
   console.log(`opencode config: ${opencodeConfigPath} (${opencodeStatus})`);
   console.log(`gateway config: ${gatewayConfigPath} (${gatewayStatus})`);
   console.log(`gateway workspace: ${workspaceDirPath} (ready)`);
+  console.log("next step: start OpenCode with `opencode-gateway serve`");
+  console.log("fallback: if you still run `opencode serve`, run `opencode-gateway warm` after startup");
+}
+
+// src/cli/serve.ts
+import { spawn } from "node:child_process";
+import { mkdir as mkdir2 } from "node:fs/promises";
+async function runServe(options, env) {
+  const target = await resolveServeTarget(options, env);
+  await mkdir2(target.workspaceDirPath, { recursive: true });
+  const child = spawn("opencode", ["serve"], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...target.env
+    }
+  });
+  warmGatewayProject(target).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`warning: ${message}`);
+    console.warn("warning: the gateway plugin may stay idle until the first project-scoped request");
+  });
+  const exitCode = await waitForChild(child);
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+}
+function waitForChild(child) {
+  return new Promise((resolve4, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal !== null) {
+        resolve4(1);
+        return;
+      }
+      resolve4(code ?? 0);
+    });
+  });
+}
+
+// src/cli/warm.ts
+import { mkdir as mkdir3 } from "node:fs/promises";
+async function runWarm(options, env) {
+  const target = await resolveServeTarget(options, env);
+  await mkdir3(target.workspaceDirPath, { recursive: true });
+  await warmGatewayProject(target);
+  console.log(`gateway plugin warmed: ${target.serverOrigin}`);
+  console.log(`warm directory: ${target.workspaceDirPath}`);
 }
 
 // src/cli.ts
@@ -482,6 +625,12 @@ async function main() {
     case "init":
       await runInit(command, process.env);
       return;
+    case "serve":
+      await runServe(command, process.env);
+      return;
+    case "warm":
+      await runWarm(command, process.env);
+      return;
   }
 }
 main().catch((error) => {

package/dist/index.js

@@ -17754,7 +17754,9 @@ function delay(durationMs) {
 
 // src/opencode/adapter.ts
 var SESSION_IDLE_POLL_MS = 250;
-var PROMPT_RESPONSE_TIMEOUT_MS = 90000;
+var PROMPT_RESPONSE_PROGRESS_TIMEOUT_MS = 90000;
+var PROMPT_RESPONSE_MAX_TIMEOUT_MS = 10 * 60000;
+var PROMPT_RESPONSE_SETTLE_MS = 1000;
 
 class OpencodeSdkAdapter {
   client;
@@ -17900,8 +17902,12 @@ class OpencodeSdkAdapter {
     };
   }
   async awaitPromptResponse(command) {
-    const deadline = Date.now() + PROMPT_RESPONSE_TIMEOUT_MS;
+    const startedAtMs = Date.now();
+    const maxDeadline = startedAtMs + PROMPT_RESPONSE_MAX_TIMEOUT_MS;
+    let progressDeadline = startedAtMs + PROMPT_RESPONSE_PROGRESS_TIMEOUT_MS;
     let stableCandidateKey = null;
+    let stableCandidateSinceMs = null;
+    let progressKey = null;
     for (;; ) {
       const messages = await this.client.session.messages({
         path: { id: command.sessionId },
@@ -17912,22 +17918,32 @@ class OpencodeSdkAdapter {
         responseStyle: "data",
         throwOnError: true
       });
-      const response = selectAssistantResponse(unwrapData(messages), command.messageId);
+      const assistantChildren = listAssistantResponses(unwrapData(messages), command.messageId);
+      const nextProgressKey = createAssistantProgressKey(assistantChildren);
+      const now = Date.now();
+      if (progressKey !== nextProgressKey) {
+        progressKey = nextProgressKey;
+        progressDeadline = now + PROMPT_RESPONSE_PROGRESS_TIMEOUT_MS;
+      }
+      const response = selectAssistantResponse(assistantChildren);
       if (response !== null) {
         const candidateKey = createAssistantCandidateKey(response);
         if (stableCandidateKey === candidateKey) {
-          return {
-            kind: "awaitPromptResponse",
-            sessionId: command.sessionId,
-            messageId: response.info.id,
-            parts: response.parts.flatMap(toBindingMessagePart)
-          };
+          if (stableCandidateSinceMs !== null && now - stableCandidateSinceMs >= PROMPT_RESPONSE_SETTLE_MS) {
+            return toAwaitPromptResponseResult(command.sessionId, response);
+          }
+        } else {
+          stableCandidateKey = candidateKey;
+          stableCandidateSinceMs = now;
         }
-        stableCandidateKey = candidateKey;
       } else {
         stableCandidateKey = null;
+        stableCandidateSinceMs = null;
       }
-      if (Date.now() >= deadline) {
+      if (now >= progressDeadline || now >= maxDeadline) {
+        if (response !== null) {
+          return toAwaitPromptResponseResult(command.sessionId, response);
+        }
         throw new Error(`assistant message for prompt ${command.messageId} is unavailable after prompt completion`);
       }
       await delay(SESSION_IDLE_POLL_MS);
@@ -17988,8 +18004,10 @@ function toSessionPromptPart(part) {
       };
   }
 }
-function selectAssistantResponse(messages, userMessageId) {
-  const assistantChildren = messages.filter(isAssistantChildMessage(userMessageId));
+function listAssistantResponses(messages, userMessageId) {
+  return messages.filter(isAssistantChildMessage(userMessageId));
+}
+function selectAssistantResponse(assistantChildren) {
   for (let index = assistantChildren.length - 1;index >= 0; index -= 1) {
     const candidate = assistantChildren[index];
     if (hasVisibleText(candidate)) {
@@ -18004,6 +18022,9 @@ function selectAssistantResponse(messages, userMessageId) {
   }
   return null;
 }
+function createAssistantProgressKey(messages) {
+  return JSON.stringify(messages.map(createAssistantCandidateKey));
+}
 function createAssistantCandidateKey(message) {
   return JSON.stringify({
     messageId: message.info.id,
@@ -18020,6 +18041,14 @@ function createAssistantCandidateKey(message) {
 function isAssistantChildMessage(userMessageId) {
   return (message) => message.info?.role === "assistant" && message.info.parentID === userMessageId;
 }
+function toAwaitPromptResponseResult(sessionId, message) {
+  return {
+    kind: "awaitPromptResponse",
+    sessionId,
+    messageId: message.info.id,
+    parts: message.parts.flatMap(toBindingMessagePart)
+  };
+}
 function toBindingMessagePart(part) {
   if (typeof part.id !== "string" || typeof part.messageID !== "string" || part.type.length === 0) {
     return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gateway",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "Gateway plugin for OpenCode",
   "license": "MIT",
   "type": "module",