ework-aio 0.2.3 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-aio",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "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.5-dev";
 
 const USAGE = `ework-aio <command> [options]
 

package/src/commands/install.ts

@@ -97,20 +97,35 @@ export async function runInstall(
   logger.ok(`preflight: bun, npm, opencode all on PATH`);
 
   // 2. Resolve ework-web / ework-daemon binaries (npm-installed global bins).
+  //
+  // ework-daemon ships TWO bins: `ework-daemon` (client CLI: status/issues/...)
+  // and `ework-daemon-server` (actual HTTP server). We start the SERVER, not
+  // the client — pre-v0.2.5 we spawned the client, which prints help and
+  // exits, leaving the daemon "looking dead" with a help-text log.
   const webBin = resolveCommand("ework-web");
-  const daemonBin = resolveCommand("ework-daemon");
+  const daemonClientBin = resolveCommand("ework-daemon");
+  const daemonServerBin = resolveCommand("ework-daemon-server");
   if (!webBin) {
     throw new InstallError(
       `ework-web binary not found on PATH. Install with: npm install -g ework-web`,
     );
   }
-  if (!daemonBin) {
+  if (!daemonClientBin && !daemonServerBin) {
+    throw new InstallError(
+      `ework-daemon not installed. Install with: npm install -g ework-daemon`,
+    );
+  }
+  if (!daemonServerBin) {
+    // Client CLI present but server bin missing — old / partial install.
     throw new InstallError(
-      `ework-daemon binary not found on PATH. Install with: npm install -g ework-daemon`,
+      `ework-daemon-server binary not found on PATH, but ework-daemon (client) is present. ` +
+        `Your ework-daemon npm install is incomplete or outdated. Reinstall with: ` +
+        `npm install -g ework-daemon@latest`,
     );
   }
-  logger.ok(`web bin    : ${webBin}`);
-  logger.ok(`daemon bin : ${daemonBin}`);
+  logger.ok(`web bin         : ${webBin}`);
+  logger.ok(`daemon client   : ${daemonClientBin ?? "(not on PATH)"}`);
+  logger.ok(`daemon server   : ${daemonServerBin}`);
 
   // 3. Resolve all filesystem paths.
   const paths = resolvePaths({
@@ -349,7 +364,7 @@ export async function runInstall(
       user: userInfo.username,
       group: userInfo.username,
       binPath: preflight.found.get("bun")!,
-      mainScript: daemonBin,
+      mainScript: daemonServerBin,
       envFile: paths.daemonEnvFile,
       workingDirectory: paths.daemonDataDir,
       logFile: paths.daemonLogFile,
@@ -388,7 +403,7 @@ export async function runInstall(
       logger.log(`starting ework-daemon (PID-file mode)...`);
       const env = await loadEnvIntoProcess(paths.daemonEnvFile);
       const { pid } = await startProcess({
-        cmd: daemonBin,
+        cmd: daemonServerBin,
         args: [],
         cwd: paths.daemonDataDir,
         env,

package/src/commands/lifecycle.ts

@@ -41,7 +41,11 @@ function servicePaths(paths: PathConfig, svc: "web" | "daemon"): ServicePaths {
     };
   }
   return {
-    bin: "ework-daemon",
+    // ework-daemon ships two bins; only `ework-daemon-server` actually starts
+    // the HTTP server. The `ework-daemon` bin is a client CLI that prints help
+    // and exits — spawning it leaves the daemon "looking dead" with help text
+    // in the log. See install.ts preflight for the full rationale.
+    bin: "ework-daemon-server",
     dataDir: paths.daemonDataDir,
     envFile: paths.daemonEnvFile,
     pidFile: paths.daemonPidFile,

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 };
 }