ework-aio 0.2.2 → 0.2.4

package/package.json

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

package/src/commands/install.ts

@@ -592,14 +592,18 @@ async function bootstrapBot(opts: BootstrapBotOpts): Promise<string> {
   }
 
   // 3. Mint PAT via /me/tokens/create. Response is HTML containing the
-  // clear-text token in `<input id="t" value="<40-hex>">`. We only get one
-  // chance to see the clear-text — must scrape it now.
+  // clear-text token. ework-web renders it inside `<code id="t">VALUE</code>`
+  // (verified at src/views/tokens.ts:141 in ework-web at time of writing);
+  // the legacy install.sh-era HTML used `<input id="t" value="VALUE">`. We
+  // scrape both shapes so an ework-web template change doesn't silently
+  // break install.
   //
   // S-3: pin redirect:"manual" so a PRG-style 303→GET doesn't land us on
   // a "token list" page where the clear-text value isn't present.
   //
-  // S-2: scrape regex is attribute-order-independent — accepts both
-  // `<input id="t" value="...">` and `<input value="..." id="t">`.
+  // Token shape: 40 lowercase hex chars (ework-web createPat uses
+  // randomHex(20) — 20 bytes → 40 hex). Case-insensitive `i` flag for
+  // XHTML-style `<INPUT VALUE="...">` and uppercase hex (defensive).
   const patRes = await fetchImpl(`${opts.baseUrl}/me/tokens/create`, {
     method: "POST",
     headers: { Cookie: botCookie, "Content-Type": "application/x-www-form-urlencoded" },
@@ -612,14 +616,14 @@ async function bootstrapBot(opts: BootstrapBotOpts): Promise<string> {
     );
   }
   const patBody = await patRes.text();
-  // S-2: scrape regex is attribute-order-independent — accepts both
-  // `<input id="t" value="...">` and `<input value="..." id="t">`.
-  // Case-insensitive (i flag) so XHTML-style `<INPUT VALUE="...">` from
-  // ework-web template tweaks doesn't silently break scraping.
-  const match = patBody.match(/<input[^>]*id="t"[^>]*value="([a-f0-9]{40})"/i)
-    ?? patBody.match(/<input[^>]*value="([a-f0-9]{40})"[^>]*id="t"/i);
+  const match =
+    patBody.match(/<code[^>]*id="t"[^>]*>\s*([a-f0-9]{40})\s*<\/code>/i) ??
+    patBody.match(/<input[^>]*id="t"[^>]*value="([a-f0-9]{40})"/i) ??
+    patBody.match(/<input[^>]*value="([a-f0-9]{40})"[^>]*id="t"/i);
   if (!match || !match[1]) {
-    throw new InstallError(`could not extract PAT from token-create response`);
+    throw new InstallError(
+      `could not extract PAT from token-create response (first 300 chars): ${patBody.slice(0, 300)}`,
+    );
   }
   return match[1];
 }

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