ework-aio 0.2.9 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-aio",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "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/scripts/e2e-browser.sh

@@ -67,6 +67,7 @@ info() { printf '%s…%s %s\n' "$c_ylw" "$c_rst" "$*" >&2; }
 WORK_PORT="${WORK_PORT:-14002}"
 DAEMON_PORT="${DAEMON_PORT:-14101}"
 FAKE_LLM_PORT="${FAKE_LLM_PORT:-8400}"
+BOT_LOGIN="${BOT_LOGIN:-e2e-bot}"
 NPM_TAG="${NPM_TAG:-latest}"
 DATA_DIR=/tmp/aio-browser
 
@@ -131,7 +132,7 @@ pass "both services responding"
 
 info "configure opencode to use fake LLM"
 # Overwrite ~/.config/opencode/opencode.json with fake provider + plugin.
-# install.ts only registers the plugin; we add the fake provider here so
+# install.ts only registers opencode-ework; we add the fake provider here so
 # the test stays isolated from any real API credentials.
 OPENCODE_CONFIG_DIR="$HOME/.config/opencode"
 mkdir -p "$OPENCODE_CONFIG_DIR"
@@ -149,6 +150,9 @@ cat > "$OPENCODE_CONFIG_DIR/opencode.json" <<OCJSON
       "models": {
         "fake-model": {
           "name": "Fake Model"
+        },
+        "e2e-daemon-override": {
+          "name": "E2E Daemon Override"
         }
       }
     }
@@ -197,6 +201,28 @@ COOKIE_SIG=$(printf '%s' "$WORK_TOKEN" \
   | base64 | tr '+/' '-_' | tr -d '=')
 AUTH_COOKIE="ework_auth=${WORK_TOKEN}.${COOKIE_SIG}"
 
+info "configure global defaultModel via /settings (model config E2E)"
+# Set defaultModel to a UNIQUE model name (different from the smoke test's
+# fake/fake-model) so we can distinguish daemon-driven spawn from smoke test.
+# If ework-daemon honors the new --model flag, fake-llm will see
+# `model=e2e-daemon-override` in the request body. If it doesn't, fake-llm
+# keeps seeing `model=fake-model` (opencode falls back to opencode.json).
+E2E_MODEL_ID="fake/e2e-daemon-override"
+SETTINGS_RESP=$(curl -sS -o /dev/null -w '%{http_code}' -X POST \
+  "http://127.0.0.1:$WORK_PORT/settings" \
+  -H "Cookie: $AUTH_COOKIE" \
+  --data-urlencode "defaultModel=$E2E_MODEL_ID")
+[[ "$SETTINGS_RESP" == "303" ]] \
+  || fail "POST /settings defaultModel=$E2E_MODEL_ID failed (status=$SETTINGS_RESP)"
+pass "global defaultModel configured: $E2E_MODEL_ID"
+# Pre-populate the model_cache so the settings UI's select shows our entry
+# (also exercises the refresh endpoint added in ework-web 0.2.0).
+curl -sS -o /dev/null -X POST \
+  "http://127.0.0.1:$WORK_PORT/settings/models/refresh" \
+  -H "Cookie: $AUTH_COOKIE" || true
+# Mark timestamp so we can scope fake-llm log analysis to AFTER this point.
+E2E_MODEL_CONFIG_TS=$(date +%s)
+
 # Create project (idempotent — if it exists, 303 is still returned).
 curl -sS -o /dev/null -w 'project: %{http_code}\n' -X POST \
   "http://127.0.0.1:$WORK_PORT/projects" \
@@ -232,6 +258,13 @@ OPENCODE_DB="$HOME/.local/share/opencode/opencode.db"
 sql_query() {
   bun -e "const db=require('bun:sqlite');const d=new db.Database('$1',{readonly:true,create:false});try{process.stdout.write(JSON.stringify(d.prepare(\`$2\`).all()))}catch(e){process.stdout.write('')}" 2>/dev/null
 }
+# The smoke test in the previous step already wrote a session row. To avoid
+# grabbing that one, capture its ID first and wait for a NEW session ID to
+# appear (the daemon spawns its own opencode against a different --dir, so
+# its session ID will differ).
+PREV_SESSION_ID=$(sql_query "$OPENCODE_DB" "SELECT id FROM session ORDER BY time_updated DESC LIMIT 1;" \
+  | jq -r '.[0].id // empty' 2>/dev/null || echo "")
+echo "  smoke test session: ${PREV_SESSION_ID:-(none yet)}"
 SESSION_ID=""
 # 180s window: opencode spawn + fake-LLM roundtrip + write to DB. The
 # daemon's poller picks up the issue within ~30s, then opencode takes
@@ -239,7 +272,7 @@ SESSION_ID=""
 for i in $(seq 1 180); do
   ROWS=$(sql_query "$OPENCODE_DB" "SELECT id FROM session ORDER BY time_updated DESC LIMIT 1;")
   SESSION_ID=$(echo "$ROWS" | jq -r '.[0].id // empty' 2>/dev/null || echo "")
-  if [[ -n "$SESSION_ID" ]]; then
+  if [[ -n "$SESSION_ID" && "$SESSION_ID" != "$PREV_SESSION_ID" ]]; then
     pass "session created: $SESSION_ID (after ${i}s)"
     break
   fi
@@ -249,7 +282,7 @@ for i in $(seq 1 180); do
     tail -40 "$DATA_DIR/run/daemon.log" 2>/dev/null || echo "(no daemon.log)"
     echo "--- fake-llm log (last 10) ---"
     tail -10 /tmp/fake-llm.log
-    fail "opencode did not write a session";
+    fail "daemon's opencode did not write a new session (last seen: $SESSION_ID)";
   }
 done
 
@@ -265,6 +298,24 @@ for i in $(seq 1 30); do
   [[ $i -eq 30 ]] && fail "session never got assistant reply (msgs=$MSG_COUNT)";
 done
 
+info "verify daemon honored --model override from ework-web defaultModel"
+# fake-llm logs `model=<X>` for each /v1/chat/completions request. The smoke
+# test ran with fake/fake-model. The daemon-driven spawn (after we set
+# defaultModel=fake/e2e-daemon-override in /settings) MUST show
+# model=e2e-daemon-override in subsequent requests. If we still see only
+# model=fake-model → daemon didn't pass --model through (regression).
+if grep -q "model=e2e-daemon-override" /tmp/fake-llm.log; then
+  pass "daemon spawn honored ework-web defaultModel (fake-llm saw model=e2e-daemon-override)"
+else
+  echo "  --- fake-llm log (model= lines only) ---"
+  grep -E 'model=' /tmp/fake-llm.log | tail -10 || echo "(no model= entries)"
+  echo "  --- daemon.log (last 30) ---"
+  tail -30 "$DATA_DIR/run/daemon.log" 2>/dev/null || echo "(no daemon.log)"
+  echo "  --- ework-web + ework-daemon installed versions ---"
+  npm ls -g ework-web ework-daemon 2>&1 | grep -E 'ework-' | head -5
+  fail "daemon did NOT pass --model through (fake-llm never saw model=e2e-daemon-override)"
+fi
+
 info "verify session is browsable via awork-web"
 # awork-web's OpencodeClient reads opencode.db and calls `opencode export`.
 # Hit the /sessions list and the specific session page. Both require the
@@ -285,6 +336,20 @@ if ! echo "$SESSIONS_HTML" | grep -q "$SESSION_ID"; then
 fi
 pass "/sessions lists the new session"
 
+# Diagnostic: capture raw `opencode export <id>` stdout to see whether plugins
+# emit banners into the JSON stream in this test environment. Production hit a
+# bug where ework-web's JSON.parse choked on these preamble lines; if they
+# appear here, the test must catch the failure rather than silently passing.
+EXPORT_RAW=$(opencode export "$SESSION_ID" 2>/dev/null </dev/null || true)
+EXPORT_LINE_COUNT=$(printf '%s\n' "$EXPORT_RAW" | wc -l)
+JSON_START_LINE=$(printf '%s\n' "$EXPORT_RAW" | grep -nE '^\s*[{]' | head -1 | cut -d: -f1 || echo 0)
+echo "  opencode export raw stdout: $EXPORT_LINE_COUNT lines, JSON object opens at line $JSON_START_LINE"
+if [[ "$EXPORT_LINE_COUNT" -gt 1 && "$JSON_START_LINE" -gt 1 ]]; then
+  echo "  --- first 5 lines (non-JSON preamble) ---"
+  printf '%s\n' "$EXPORT_RAW" | head -5 | sed 's/^/    /'
+  echo "  WARNING: stdout has non-JSON preamble — ework-web's old JSON.parse would fail here"
+fi
+
 SESSION_PAGE_HTML=$(curl -sS -H "Cookie: $AUTH_COOKIE" "http://127.0.0.1:$WORK_PORT/sessions/$SESSION_ID")
 # Look for any marker that the fake LLM reply rendered. The reply body always
 # starts with "E2E fake-LLM reply" so we grep for that substring.
@@ -292,6 +357,35 @@ echo "$SESSION_PAGE_HTML" | grep -q "E2E fake-LLM" \
   || fail "session page does not contain fake-LLM reply text"
 pass "session page renders fake-LLM reply content"
 
+info "check whether the bot actually replied on the issue (auto-reply)"
+# ework-web exposes the issue comments via /api/v1/repos/<o>/<r>/issues/<n>/comments
+# (Gitea-compatible). Two distinct kinds of bot-authored comments exist:
+#   1. [system] "picked up this issue" — posted by the daemon on session start
+#      (NOT an LLM reply; doesn't count).
+#   2. [bot] actual reply — posted by the LLM via the opencode-ework `reply`
+#      tool. This is the auto-reply behaviour we're validating.
+COMMENTS_JSON=$(curl -sS -H "Cookie: $AUTH_COOKIE" \
+  "http://127.0.0.1:$WORK_PORT/api/v1/repos/e2e/browser-test/issues/1/comments")
+COMMENTS_COUNT=$(echo "$COMMENTS_JSON" | jq 'length' 2>/dev/null || echo 0)
+BOT_COMMENTS_COUNT=$(echo "$COMMENTS_JSON" \
+  | jq --arg bot "$BOT_LOGIN" '[.[] | select(.user.login == $bot)] | length' 2>/dev/null || echo 0)
+LLM_REPLIES=$(echo "$COMMENTS_JSON" \
+  | jq --arg bot "$BOT_LOGIN" \
+       '[.[] | select(.user.login == $bot and (.body | startswith("[bot]")))] | length' 2>/dev/null || echo 0)
+echo "  comments on issue #1: total=$COMMENTS_COUNT bot=$BOT_COMMENTS_COUNT llm-reply=$LLM_REPLIES"
+echo "  --- all bot comment bodies (first 400 chars each) ---"
+echo "$COMMENTS_JSON" | jq -r --arg bot "$BOT_LOGIN" \
+  '.[] | select(.user.login == $bot) | "  • " + (.body | .[0:400])' 2>/dev/null
+if [[ "$LLM_REPLIES" -ge 1 ]]; then
+  pass "bot auto-replied on issue #1 ($LLM_REPLIES [bot]-prefixed LLM reply)"
+else
+  echo "  --- daemon.log (last 40) ---"
+  tail -40 "$DATA_DIR/run/daemon.log" 2>/dev/null || echo "(no daemon.log)"
+  echo "  --- fake-llm.log (last 20) ---"
+  tail -20 /tmp/fake-llm.log 2>/dev/null
+  fail "bot did NOT post an LLM-driven reply on issue #1 (got $BOT_COMMENTS_COUNT bot comments but 0 starting with [bot])"
+fi
+
 info "drive headless browser through the UI"
 # bun (not tsx) because the script imports `bun:sqlite` to peek at opencode.db.
 cp /host-test/browser-flow.ts /tmp/test-runner/

package/scripts/fake-llm-server.ts

@@ -76,6 +76,9 @@ async function handleChatCompletion(req: Request): Promise<Response> {
   log(`  body: stream=${body?.stream} model=${body?.model} msgs=${body?.messages?.length} tools=${body?.tools?.length ?? 0}`);
 
   const messages = Array.isArray(body?.messages) ? body.messages : [];
+  const tools = Array.isArray(body?.tools) ? body.tools : [];
+  const lastMsg = messages[messages.length - 1];
+  const lastRole = lastMsg?.role;
   const userMsgs = messages.filter((m: any) => m?.role === "user");
   const lastUser = userMsgs[userMsgs.length - 1];
   const userText = typeof lastUser?.content === "string"
@@ -84,6 +87,36 @@ async function handleChatCompletion(req: Request): Promise<Response> {
       ? lastUser.content.map((p: any) => p?.text ?? "").join(" ")
       : "";
 
+  const hasReplyTool = tools.some((t: any) => t?.function?.name === "reply");
+
+  // Tool-call path: when `reply` is registered and the last message is the
+  // user's initial prompt (not a tool_result), emit a tool_use so opencode
+  // actually invokes the reply tool → ework-web posts a [bot] comment on the
+  // issue. Without this the daemon only posts its [system] "picked up"
+  // notification and the LLM-driven auto-reply loop never fires.
+  //
+  // After opencode executes the tool it makes a follow-up call with
+  // role=tool in the messages — at that point we drop back to text.
+  if (hasReplyTool && lastRole === "user") {
+    const ref = parseIssueRef(userText);
+    if (ref) {
+      log(`  emitting reply tool_use → ${ref.owner}/${ref.repo}#${ref.number}`);
+      const toolReplyBody =
+        `[bot] E2E fake-LLM auto-reply.\n\n` +
+        `Picked up ${ref.owner}/${ref.repo}#${ref.number}. ` +
+        `This is a stub reply emitted by scripts/fake-llm-server.ts to exercise ` +
+        `the opencode-ework \`reply\` tool end-to-end. The real value of this ` +
+        `test is that opencode received a tool_use, executed the reply tool, ` +
+        `and ework-web posted this comment as ${process.env.BOT_USERNAME ?? "bot"}.`;
+      return toolCallResponse(body?.model ?? "fake-model", "reply", {
+        owner: ref.owner,
+        repo: ref.repo,
+        number: ref.number,
+        body: toolReplyBody,
+      }, body?.stream === true);
+    }
+  }
+
   // Deterministic, context-aware reply: echo a snippet of the user's last
   // message so the session transcript has traceable content (not just a
   // fixed string). Truncated so the reply stays readable in the UI.
@@ -128,6 +161,133 @@ async function handleChatCompletion(req: Request): Promise<Response> {
   });
 }
 
+// Parse an issue ref of the form `<owner>/<repo>#<n>` out of arbitrary text
+// (typically the user prompt built by ework-daemon's buildInitialPrompt,
+// which includes "(gitea:owner/repo#N)"). Returns null if no match.
+function parseIssueRef(text: string): { owner: string; repo: string; number: number } | null {
+  const m = text.match(/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)#(\d+)/);
+  if (!m) return null;
+  const [, owner, repo, num] = m;
+  const number = parseInt(num, 10);
+  if (!Number.isFinite(number)) return null;
+  return { owner, repo, number };
+}
+
+// Emit a tool_use response (OpenAI function-calling format). Supports both
+// streaming and non-streaming because opencode defaults to stream=true but
+// curl smoke tests use non-streaming.
+function toolCallResponse(model: string, toolName: string, args: Record<string, unknown>, stream: boolean): Response {
+  const id = `chatcmpl-fake-${crypto.randomUUID()}`;
+  const created = Math.floor(Date.now() / 1000);
+  const callId = `call_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  const argsJson = JSON.stringify(args);
+  const usage = {
+    prompt_tokens: roughTokens(argsJson),
+    completion_tokens: roughTokens(argsJson),
+    total_tokens: roughTokens(argsJson) * 2,
+  };
+
+  if (!stream) {
+    return json({
+      id,
+      object: "chat.completion",
+      created,
+      model,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: null,
+            tool_calls: [
+              {
+                id: callId,
+                type: "function",
+                function: { name: toolName, arguments: argsJson },
+              },
+            ],
+          },
+          finish_reason: "tool_calls",
+        },
+      ],
+      usage,
+    });
+  }
+
+  const encoder = new TextEncoder();
+  const readable = new ReadableStream({
+    start(controller) {
+      // Initial chunk: declare the tool_call with name + empty arguments.
+      controller.enqueue(
+        encoder.encode(
+          sseLine({
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: {
+                role: "assistant",
+                content: null,
+                tool_calls: [{
+                  index: 0,
+                  id: callId,
+                  type: "function",
+                  function: { name: toolName, arguments: "" },
+                }],
+              },
+              finish_reason: null,
+            }],
+          }),
+        ),
+      );
+      // Arguments chunk: full JSON in one shot (splitting is optional).
+      controller.enqueue(
+        encoder.encode(
+          sseLine({
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: {
+                tool_calls: [{ index: 0, function: { arguments: argsJson } }],
+              },
+              finish_reason: null,
+            }],
+          }),
+        ),
+      );
+      // Final chunk: finish_reason + usage.
+      controller.enqueue(
+        encoder.encode(
+          sseLine({
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
+            usage,
+          }),
+        ),
+      );
+      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      controller.close();
+    },
+  });
+
+  return new Response(readable, {
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      "connection": "keep-alive",
+      "access-control-allow-origin": "*",
+    },
+  });
+}
+
 function streamResponse(model: string, reply: string, usage: any): Response {
   const id = `chatcmpl-fake-${crypto.randomUUID()}`;
   const created = Math.floor(Date.now() / 1000);

package/src/commands/install.ts

@@ -24,7 +24,7 @@ import { resolvePaths, type PathConfig } from "../paths.ts";
 import { type InstallContext } from "../config.ts";
 import { ensureEnvFile, parseEnvFile, patchEnvKey } from "../env.ts";
 import { startProcess, isProcessRunning, readPidFile } from "../pidfile.ts";
-import { checkPreflight, resolveCommand, REQUIRED_COMMANDS } from "../preflight.ts";
+import { checkPreflight, resolveCommand, resolveBundledBin, REQUIRED_COMMANDS } from "../preflight.ts";
 import {
   generateUnitFile,
   writeUnitFile,
@@ -96,31 +96,45 @@ export async function runInstall(
   const opencodeBin = preflight.found.get("opencode")!;
   logger.ok(`preflight: bun, npm, opencode all on PATH`);
 
-  // 2. Resolve ework-web / ework-daemon binaries (npm-installed global bins).
+  // 2. Resolve ework-web / ework-daemon binaries.
   //
   // 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 daemonClientBin = resolveCommand("ework-daemon");
-  const daemonServerBin = resolveCommand("ework-daemon-server");
+  //
+  // B-1: ework-web / ework-daemon are declared dependencies of ework-aio, so
+  // they are always bundled in our own node_modules. Resolve from there first
+  // (self-contained), falling back to PATH for dev/standalone installs.
+  // Relying on PATH alone broke after uninstall+reinstall: npm does not
+  // reliably recreate global bin symlinks for reinstalled deps even though
+  // the package is present in node_modules — so install wrongly demanded
+  // "install ework-web first" for a package that is ework-aio's own job to
+  // provide.
+  const webBin = resolveBundledBin("ework-web", "bin/ework-web.js")
+    ?? resolveCommand("ework-web");
+  const daemonClientBin = resolveBundledBin("ework-daemon", "src/cli.ts")
+    ?? resolveCommand("ework-daemon");
+  const daemonServerBin = resolveBundledBin("ework-daemon", "bin/ework-daemon-server.js")
+    ?? resolveCommand("ework-daemon-server");
   if (!webBin) {
     throw new InstallError(
-      `ework-web binary not found on PATH. Install with: npm install -g ework-web`,
+      `ework-web not found. It ships as part of ework-aio; your ework-aio install is incomplete. ` +
+      `Reinstall with: npm install -g ework-aio@latest`,
     );
   }
   if (!daemonClientBin && !daemonServerBin) {
     throw new InstallError(
-      `ework-daemon not installed. Install with: npm install -g ework-daemon`,
+      `ework-daemon not found. It ships as part of ework-aio; your ework-aio install is incomplete. ` +
+      `Reinstall with: npm install -g ework-aio@latest`,
     );
   }
   if (!daemonServerBin) {
     // Client CLI present but server bin missing — old / partial install.
     throw new InstallError(
-      `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`,
+      `ework-daemon-server binary not found, but ework-daemon (client) is present. ` +
+        `Your ework-aio install is incomplete or outdated. Reinstall with: ` +
+        `npm install -g ework-aio@latest`,
     );
   }
   logger.ok(`web bin         : ${webBin}`);

package/src/preflight.ts

@@ -1,4 +1,13 @@
 import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+// Root of the ework-aio package itself. Derived from this file's location
+// (<root>/src/preflight.ts). Used to resolve bins that ework-aio ships as
+// declared dependencies (ework-web, ework-daemon) from our own node_modules,
+// so install does not depend on npm having created a global bin symlink.
+// Overridable via AIO_PACKAGE_ROOT (for tests / non-standard install prefix).
+const DEFAULT_PACKAGE_ROOT = path.join(import.meta.dir, "..");
 
 export interface PreflightResult {
   missing: string[];
@@ -23,6 +32,19 @@ export function resolveCommand(cmd: string): string | null {
   return path === "" ? null : path;
 }
 
+// Resolve a bin that ework-aio ships as a declared dependency, from our own
+// node_modules. ework-web / ework-daemon are listed as deps in package.json,
+// so they are always bundled. We must use them instead of requiring a global
+// PATH bin: npm does not reliably recreate global bin symlinks after
+// uninstall+reinstall, which previously made `ework-aio install` wrongly tell
+// the user to "install ework-web first" even though it was already bundled
+// (B-1). Returns the absolute bin path, or null if not bundled.
+export function resolveBundledBin(pkgName: string, binRelPath: string): string | null {
+  const root = process.env.AIO_PACKAGE_ROOT || DEFAULT_PACKAGE_ROOT;
+  const candidate = path.join(root, "node_modules", pkgName, binRelPath);
+  return fs.existsSync(candidate) ? candidate : null;
+}
+
 export function checkPreflight(
   required: string[],
   opts: PreflightOptions = {},