ework-aio 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-aio",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "All-in-one installer for ework (issue tracker) + ework-daemon (AI bridge) + opencode-ework (plugin). One command: npm i -g ework-aio && ework-aio install.",
   "type": "module",
   "license": "MIT",

package/src/cli.ts

@@ -35,7 +35,7 @@ import {
   type ConfigArgs,
 } from "./commands/config.ts";
 
-const VERSION = "0.2.3-dev";
+const VERSION = "0.2.4-dev";
 
 const USAGE = `ework-aio <command> [options]
 

package/src/opencode-config.ts

@@ -6,10 +6,30 @@ import fs from "node:fs";
 import path from "node:path";
 import { InstallError } from "./log.ts";
 
+// Per https://opencode.ai/config.json (verified v1.14.x), the top-level
+// schema key is "plugin" (singular), an array. Each entry is either a
+// string ("opencode-ework@latest") or a 2-tuple [name, options]. The
+// schema sets additionalProperties: false at top level, so any other key
+// name — including the plausible-looking "plugins" plural — is rejected
+// with "Unrecognized key" and breaks every opencode command that parses
+// config (export, session list, etc).
+//
+// v0.2.0-v0.2.3 wrote the WRONG key ("plugins"). On the user's machine
+// the result was: install completes, but clicking any session in
+// awork-web fails because awork-web calls `opencode export ses_xxx`,
+// opencode parses its config first, and aborts with "Unrecognized key:
+// plugins". This file now writes the correct key, and the reader
+// transparently migrates any legacy "plugins" array into "plugin" so
+// reinstall fixes existing broken configs without manual editing.
 export interface OpencodeConfig {
-  // Unknown-key passthrough — preserves fields we don't know about.
   [key: string]: unknown;
-  plugins?: Array<string | { name: string; [k: string]: unknown }>;
+  // Accepted entry shapes (we are lenient on read):
+  //   - "name@version"     (opencode schema — canonical)
+  //   - ["name", {...opts}] (opencode schema — 2-tuple form)
+  //   - { name: "..." }     (legacy from earlier ework-aio; opencode
+  //                          rejects this, but we preserve through
+  //                          read+write so users don't lose data)
+  plugin?: Array<string | [string, unknown] | { name: string; [k: string]: unknown }>;
 }
 
 export interface ReadConfigResult {
@@ -43,7 +63,7 @@ export async function readConfig(configPath: string): Promise<ReadConfigResult>
     );
   }
 
-  return { config: parsed as OpencodeConfig, existed: true };
+  return { config: migrateLegacyPluginsKey(parsed as OpencodeConfig), existed: true };
 }
 
 export async function writeConfig(configPath: string, config: OpencodeConfig): Promise<void> {
@@ -60,9 +80,42 @@ export async function writeConfig(configPath: string, config: OpencodeConfig): P
   }
 }
 
+// migrateLegacyPluginsKey: if a config has the v0.2.0-v0.2.3 "plugins"
+// (plural) key from our earlier broken installer, merge its contents
+// into the correct "plugin" key and drop the bad key. Idempotent — if
+// the user re-runs install with the fixed version, their config gets
+// healed automatically. Returns the original config object untouched if
+// no migration was needed.
+function migrateLegacyPluginsKey(config: OpencodeConfig): OpencodeConfig {
+  const legacy = config.plugins;
+  if (!Array.isArray(legacy)) {
+    // Either no legacy key, or it's malformed (not an array). Delete
+    // either way so we don't persist an unrecognized key back to disk.
+    if ("plugins" in config) {
+      const next = { ...config };
+      delete next.plugins;
+      return next;
+    }
+    return config;
+  }
+  const next: OpencodeConfig = { ...config };
+  delete next.plugins;
+  const canonical = Array.isArray(config.plugin) ? [...config.plugin] : [];
+  for (const entry of legacy) {
+    const name = normalizePluginEntry(entry);
+    if (!name) continue;
+    const already = canonical.some((e) => normalizePluginEntry(e) === name);
+    if (!already) canonical.push(entry);
+  }
+  next.plugin = canonical;
+  return next;
+}
+
 function normalizePluginEntry(entry: unknown): string | null {
-  // Plugin entries can be either "name" (string) or { name: "...", ...opts }.
   if (typeof entry === "string") return entry;
+  if (Array.isArray(entry) && entry.length >= 1 && typeof entry[0] === "string") {
+    return entry[0];
+  }
   if (entry !== null && typeof entry === "object") {
     const name = (entry as { name?: unknown }).name;
     if (typeof name === "string") return name;
@@ -71,9 +124,9 @@ function normalizePluginEntry(entry: unknown): string | null {
 }
 
 export function hasPlugin(config: OpencodeConfig, pluginName: string): boolean {
-  const plugins = config.plugins;
-  if (!Array.isArray(plugins)) return false;
-  return plugins.some((p) => normalizePluginEntry(p) === pluginName);
+  const list = config.plugin;
+  if (!Array.isArray(list)) return false;
+  return list.some((p) => normalizePluginEntry(p) === pluginName);
 }
 
 export function ensurePlugin(config: OpencodeConfig, pluginName: string): { config: OpencodeConfig; added: boolean } {
@@ -81,7 +134,7 @@ export function ensurePlugin(config: OpencodeConfig, pluginName: string): { conf
     return { config, added: false };
   }
   const next: OpencodeConfig = { ...config };
-  next.plugins = [...(Array.isArray(config.plugins) ? config.plugins : []), pluginName];
+  next.plugin = [...(Array.isArray(config.plugin) ? config.plugin : []), pluginName];
   return { config: next, added: true };
 }
 
@@ -90,15 +143,17 @@ export function removePlugin(config: OpencodeConfig, pluginName: string): { conf
     return { config, removed: false };
   }
   const next: OpencodeConfig = { ...config };
-  const plugins = Array.isArray(config.plugins) ? config.plugins : [];
-  next.plugins = plugins.filter((p) => normalizePluginEntry(p) !== pluginName);
+  const list = Array.isArray(config.plugin) ? config.plugin : [];
+  next.plugin = list.filter((p) => normalizePluginEntry(p) !== pluginName);
   return { config: next, removed: true };
 }
 
 export async function ensurePluginInFile(configPath: string, pluginName: string): Promise<{ added: boolean }> {
   const { config } = await readConfig(configPath);
   const result = ensurePlugin(config, pluginName);
-  if (!result.added) return { added: false };
+  // Always write — readConfig may have migrated a legacy "plugins" key,
+  // and we want to persist the corrected shape to disk even if the
+  // plugin was already present under the (now-renamed) "plugin" key.
   await writeConfig(configPath, result.config);
-  return { added: true };
+  return { added: result.added };
 }