@sjawhar/opencode-legion-envoy 0.7.0 → 0.9.0

package/src/config/index.ts

@@ -2,32 +2,38 @@ import { existsSync, readFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { messageFor } from "@legion/envoy-client/errors";
-import { logger } from "../log";
 import { type EnvoyConfig, EnvoyConfigSchema } from "./schema";
 
 export interface LoadEnvoyConfigOptions {
   homeDir?: string;
 }
 
+/** A present but unusable envoy.json. The plugin refuses to load rather than run with dispatch silently off. */
+export class EnvoyConfigError extends Error {
+  readonly filePath: string;
+  constructor(filePath: string, detail: string) {
+    super(`[envoy-plugin] invalid config at ${filePath}: ${detail}`);
+    this.name = "EnvoyConfigError";
+    this.filePath = filePath;
+  }
+}
+
 function readConfigFile(filePath: string): EnvoyConfig | null {
   if (!existsSync(filePath)) return null;
+  let raw: unknown;
   try {
-    const content = readFileSync(filePath, "utf-8");
-    const raw = JSON.parse(content) as unknown;
-    const parsed = EnvoyConfigSchema.safeParse(raw);
-    if (!parsed.success) {
-      const issues = parsed.error.issues
-        .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
-        .join(", ");
-      logger.warn(`[envoy-plugin] Invalid config at ${filePath}: ${issues}`);
-      return null;
-    }
-    return parsed.data as EnvoyConfig;
+    raw = JSON.parse(readFileSync(filePath, "utf-8")) as unknown;
   } catch (error) {
-    const message = messageFor(error);
-    logger.warn(`[envoy-plugin] Failed to load config at ${filePath}: ${message}`);
-    return null;
+    throw new EnvoyConfigError(filePath, messageFor(error));
+  }
+  const parsed = EnvoyConfigSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issues = parsed.error.issues
+      .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+      .join(", ");
+    throw new EnvoyConfigError(filePath, issues);
   }
+  return parsed.data;
 }
 
 function mergeConfig(base: EnvoyConfig, override: EnvoyConfig): EnvoyConfig {

package/src/config/schema.ts

@@ -6,11 +6,6 @@ export const DispatchConfigSchema = z
   .object({
     enabled: z.boolean().optional(),
     serverUrl: z.string().url().optional(),
-    defaultRepo: z
-      .string()
-      .regex(/^[^/]+\/[^/]+$/)
-      .optional(),
-    appClientId: z.string().optional(),
   })
   .strict();
 

package/src/server.ts

@@ -1,3 +1,6 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { agentSubject } from "@legion/contracts";
 import { envoyDefaultsFromEnvironment } from "@legion/envoy-client/defaults";
 import { dispatchSubscriptionTopic } from "@legion/envoy-client/dispatch-subscribe";
@@ -10,6 +13,18 @@ import { buildDispatchMcpEntry, injectEnvoyMcp } from "./dispatch-mcp";
 import { logger } from "./log";
 import { resolvePort } from "./port";
 
+const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+// Legion skills ship inside this package so OpenCode carries them without a
+// vendor checkout. OpenCode discovers skills only from fixed directories and
+// `config.skills.paths` — never from plugin package dirs — so the config hook
+// below must inject this path itself.
+//   Published tarball: dist/src/server.js → <pkg>/skills (staged at prepack).
+//   Repo checkout:     src/server.ts      → <repo>/skills.
+const skillsDirectory = [
+  path.resolve(moduleDirectory, "../../skills"),
+  path.resolve(moduleDirectory, "../../../skills"),
+].find((dir) => existsSync(dir));
+
 const [
   subscribeSpec,
   unsubscribeSpec,
@@ -139,7 +154,20 @@ export default async (input: { serverUrl: URL }) => {
   });
 
   return {
-    config: (cfg: { mcp?: Record<string, unknown> } & Record<string, unknown>) => {
+    config: (
+      cfg: { mcp?: Record<string, unknown>; skills?: { paths?: string[] } } & Record<
+        string,
+        unknown
+      >
+    ) => {
+      // Serve the bundled legion skills to every session on this serve.
+      if (skillsDirectory) {
+        cfg.skills ??= {};
+        cfg.skills.paths ??= [];
+        if (!cfg.skills.paths.includes(skillsDirectory)) {
+          cfg.skills.paths.push(skillsDirectory);
+        }
+      }
       // Inject the envoy MCP entry into the OpenCode config when
       // dispatch is enabled. Centralizing this in the plugin (instead of
       // each user's opencode.json) means: