harness-wingman 0.6.1 → 0.8.0

package/apps/cli/dist/main.js

@@ -13243,9 +13243,9 @@ var init_dist5 = __esm({
 // apps/cli/dist/main.js
 init_dist2();
 init_dist();
-import { readFileSync as readFileSync17 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
-import { dirname as dirname18, resolve as resolve11 } from "node:path";
+import { dirname as dirname19, resolve as resolve12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/fixtures/dist/index.js
@@ -13373,7 +13373,7 @@ function isHookPayload(value) {
 }
 var HOOK_BODY_LIMIT = 1024 * 1024;
 function readBody(req) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const chunks = [];
     let size = 0;
     req.on("data", (chunk) => {
@@ -13385,7 +13385,7 @@ function readBody(req) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve12(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve13(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -13980,7 +13980,7 @@ function isRecord2(value) {
 
 // packages/narrative/dist/parse.js
 function isHarnessSystemNotice(text) {
-  return /^\s*<(task-notification|system-reminder)\b/u.test(text);
+  return /^\s*<(task-notification|system-reminder|in-app-browser-context)\b/u.test(text);
 }
 function parseTranscriptLine(line) {
   const trimmed = line.trim();
@@ -15606,7 +15606,7 @@ function resolveWingmanVersion({ defined, moduleUrl = import.meta.url, readPacka
   return void 0;
 }
 function wingmanVersion() {
-  const defined = false ? void 0 : "0.6.1";
+  const defined = false ? void 0 : "0.8.0";
   return resolveWingmanVersion({
     defined,
     readPackage: (url) => JSON.parse(readFileSync15(url, "utf8"))
@@ -16014,10 +16014,23 @@ function createNarrativeService(options = {}) {
     session.follows.set(path, followTranscript(path, (line) => {
       if (closed || generation !== session.generation)
         return;
-      if (harness === "codex")
-        session.codexLines.push(parseCodexRolloutLine(line));
-      else
-        session.lines.push(parseTranscriptLine(line));
+      let timestamp;
+      if (harness === "codex") {
+        const parsed = parseCodexRolloutLine(line);
+        session.codexLines.push(parsed);
+        if (parsed.kind !== "unknown")
+          timestamp = parsed.timestamp;
+      } else {
+        const parsed = parseTranscriptLine(line);
+        session.lines.push(parsed);
+        if (parsed.kind !== "unknown")
+          timestamp = parsed.timestamp;
+      }
+      const endedAt = session.endedAt ?? session.stopAt;
+      if (timestamp !== void 0 && endedAt !== void 0 && Date.parse(timestamp) > Date.parse(endedAt)) {
+        session.endedAt = void 0;
+        session.stopAt = void 0;
+      }
       recordToolObservations(harness, session, extractRawToolObservations(harness, line));
       session.dirty = true;
       notify(harness);
@@ -16138,13 +16151,8 @@ function createNarrativeService(options = {}) {
         };
       }
     }
-    if (name === "SessionEnd") {
-      session.endedAt = event.received_at;
-    } else if (name === "Stop") {
-      session.stopAt = event.received_at;
-    } else {
-      session.stopAt = void 0;
-    }
+    session.endedAt = name === "SessionEnd" ? event.received_at : void 0;
+    session.stopAt = name === "Stop" ? event.received_at : void 0;
     session.lastEvent = { name, at: event.received_at };
     session.dirty = true;
     notify(event.harness);
@@ -16457,6 +16465,7 @@ function createNarrativeService(options = {}) {
         };
       }
       projects.push({
+        firstScreen: deriveProjectFirstScreen(plan, parsed?.availability === "available" ? parsed.goal : void 0, summary.currentPoints, sessionViews),
         root,
         presence: members.length === 0 ? "remembered" : "active",
         seenSinceStart: seenProjectRoots.has(rootIdentity),
@@ -16479,7 +16488,11 @@ function createNarrativeService(options = {}) {
         sessions: sessionViews
       });
     }
-    projects.sort((left, right) => left.root.localeCompare(right.root));
+    projects.sort((left, right) => {
+      const decisionOrder = Number(right.firstScreen.action.kind === "decision") - Number(left.firstScreen.action.kind === "decision");
+      const activityOrder = (right.firstScreen.lastActivity === void 0 ? 0 : Date.parse(right.firstScreen.lastActivity.at)) - (left.firstScreen.lastActivity === void 0 ? 0 : Date.parse(left.firstScreen.lastActivity.at));
+      return decisionOrder || activityOrder || left.root.localeCompare(right.root);
+    });
     return {
       projects,
       ...projectMemoryUnavailable === void 0 ? {} : { memory: { unavailable: projectMemoryUnavailable } }
@@ -16507,6 +16520,107 @@ function createNarrativeService(options = {}) {
   loadRememberedProjectRoots();
   return { handleEvent, getState, getOverview, getProjects, seedFixture, subscribe, close };
 }
+function deriveProjectFirstScreen(plan, goal, points, sessions) {
+  const source = ".wingman/plan.md nodes(status, children)";
+  const currentPoints = points.map((point) => ({ ...point, source }));
+  const branch = [];
+  const checkpoints = [];
+  function visit(node, ancestors) {
+    const path = [...ancestors, node];
+    const childCurrent = node.children.map((child) => visit(child, path)).some(Boolean);
+    const onCurrentPath = node.status === "in_progress" || childCurrent;
+    if (onCurrentPath && (node.status === "checkpoint" || node.verification !== void 0)) {
+      checkpoints.push({
+        key: node.key,
+        path: path.map((ancestor) => ancestor.text),
+        text: node.text,
+        source: `.wingman/plan.md:${node.line} status / verification`,
+        ...node.verification === void 0 ? {} : { verification: node.verification }
+      });
+    }
+    return onCurrentPath;
+  }
+  if (plan.availability === "available") {
+    for (const node of plan.nodes) {
+      if (visit(node, []))
+        branch.push({
+          key: node.key,
+          path: [node.text],
+          text: node.text,
+          source: `.wingman/plan.md:${node.line} \u5F53\u524D\u70B9\u9876\u5C42\u7956\u5148`
+        });
+    }
+  }
+  const requests = [];
+  for (const session of sessions) {
+    if (session.feedback?.state !== "needs_user")
+      continue;
+    requests.push({
+      harness: session.harness,
+      sessionId: session.id,
+      label: session.label,
+      since: session.feedback.since,
+      source: session.feedback.source,
+      ...session.feedback.message === void 0 ? {} : { text: session.feedback.message }
+    });
+  }
+  let action;
+  if (requests.length > 0)
+    action = { kind: "decision", items: requests, source: "sessions.feedback(state=needs_user)" };
+  else if (checkpoints.length > 0)
+    action = {
+      kind: "checkpoint",
+      items: checkpoints,
+      source: ".wingman/plan.md \u5F53\u524D\u70B9\u7956\u5148\u8DEF\u5F84 status / verification"
+    };
+  else if (plan.availability === "missing")
+    action = {
+      kind: "insufficient",
+      reason: "no_plan",
+      source: "plan.availability=missing; plan.lookedUp"
+    };
+  else if (plan.availability === "unavailable")
+    action = {
+      kind: "insufficient",
+      reason: "plan_unavailable",
+      source: `plan.availability=unavailable; plan.reason: ${plan.reason}`
+    };
+  else if (sessions.length > 0 && sessions.every((session) => session.feedback === void 0 || session.feedback.state === "unavailable"))
+    action = {
+      kind: "insufficient",
+      reason: "feedback_unavailable",
+      source: "sessions.feedback.state=unavailable / feedback \u672A\u63D0\u4F9B"
+    };
+  else if (currentPoints.length > 0 && sessions.some((session) => !session.ended))
+    action = {
+      kind: "in_progress",
+      source: ".wingman/plan.md currentPoints; sessions.ended=false"
+    };
+  else
+    action = {
+      kind: "insufficient",
+      reason: "no_session",
+      source: `currentPoints.length=${currentPoints.length}; sessions(ended=false).length=${sessions.filter((session) => !session.ended).length}`
+    };
+  const latest = sessions.filter((session) => session.lastActivity !== void 0 && Number.isFinite(Date.parse(session.lastActivity))).sort((left, right) => Date.parse(right.lastActivity) - Date.parse(left.lastActivity))[0];
+  return {
+    source,
+    branch,
+    currentPoints,
+    action,
+    ...goal === void 0 ? {} : { goal: { text: goal, source: ".wingman/plan.md \u76EE\u6807: / Goal:" } },
+    ...latest === void 0 ? {} : {
+      lastActivity: {
+        at: latest.lastActivity,
+        harness: latest.harness,
+        sessionId: latest.id,
+        label: latest.user.title ?? (latest.title.source === "plan.md \u6B65\u9AA4" ? latest.title.text : latest.label),
+        source: "sessions.lastActivity\uFF08\u6700\u8FD1 hook received_at / transcript timestamp\uFF09\u6700\u5927\u503C",
+        labelSource: latest.user.title !== void 0 ? "sessions.user.title" : latest.title.source === "plan.md \u6B65\u9AA4" ? "sessions.title\uFF08plan.md \u6B65\u9AA4\uFF09" : "sessions.label\uFF08\u4F1A\u8BDD\u5DE5\u4F5C\u76EE\u5F55\u540D / sessionId\uFF09"
+      }
+    }
+  };
+}
 function lastActivityOf(session) {
   if (session.lastActivity !== void 0)
     return session.lastActivity;
@@ -17510,10 +17624,108 @@ async function scanValidated(adapter, options) {
 
 // apps/cli/dist/server.js
 init_dist();
+import { execFile as execFile2 } from "node:child_process";
 import { createHmac, timingSafeEqual } from "node:crypto";
 import { readFile as readFile4 } from "node:fs/promises";
 import { createServer } from "node:http";
-import { extname, resolve as resolve10, sep as sep2 } from "node:path";
+import { extname, resolve as resolve11, sep as sep2 } from "node:path";
+
+// apps/cli/dist/return-target.js
+import { randomBytes as randomBytes5 } from "node:crypto";
+import { closeSync as closeSync4, copyFileSync as copyFileSync2, mkdirSync as mkdirSync12, openSync as openSync4, readFileSync as readFileSync17, renameSync as renameSync6, rmSync as rmSync10, statSync as statSync6, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname18, join as join24, resolve as resolve10 } from "node:path";
+var BUNDLES = [
+  ["Terminal", "Terminal.app"],
+  ["iTerm", "iTerm.app"],
+  ["Ghostty", "Ghostty.app"],
+  ["WezTerm", "WezTerm.app"],
+  ["Warp", "Warp.app"],
+  ["Alacritty", "Alacritty.app"],
+  ["kitty", "kitty.app"],
+  ["VS Code", "Visual Studio Code.app"]
+];
+function detectReturnTargets(homeDir, roots = ["/Applications", join24(homeDir, "Applications")]) {
+  const available = [];
+  for (const [name, bundle] of BUNDLES) {
+    for (const root of new Set(roots.map((root2) => resolve10(root2)))) {
+      const bundlePath = join24(root, bundle);
+      try {
+        if (statSync6(bundlePath).isDirectory())
+          available.push({ name, bundlePath });
+      } catch {
+      }
+    }
+  }
+  return available;
+}
+function settingsPath(homeDir) {
+  return join24(homeDir, ".wingman", "state", "settings.json");
+}
+function readReturnTargetSettings(homeDir) {
+  let raw;
+  try {
+    raw = readFileSync17(settingsPath(homeDir), "utf8");
+  } catch (error) {
+    if (isRecord8(error) && error.code === "ENOENT")
+      return { version: 1 };
+    return { unavailable: "\u56DE\u8DF3\u8BBE\u7F6E\u65E0\u6CD5\u8BFB\u53D6;\u8BF7\u4EBA\u5DE5\u68C0\u67E5 settings.json" };
+  }
+  try {
+    const value = JSON.parse(raw);
+    if (!isSettings(value))
+      throw new Error("\u4E0D\u662F\u5408\u6CD5 v1 \u7ED3\u6784");
+    return value;
+  } catch {
+    return { unavailable: "\u56DE\u8DF3\u8BBE\u7F6E\u65E0\u6CD5\u89E3\u6790\u6216\u7248\u672C\u672A\u77E5,\u62D2\u7EDD\u8986\u76D6;\u8BF7\u4EBA\u5DE5\u68C0\u67E5 settings.json" };
+  }
+}
+function saveReturnTarget(homeDir, bundlePath) {
+  const current = readReturnTargetSettings(homeDir);
+  if ("unavailable" in current)
+    return current;
+  const settings = { version: 1, returnTarget: { bundlePath } };
+  const path = settingsPath(homeDir);
+  const tempPath = join24(dirname18(path), `.settings-${randomBytes5(8).toString("hex")}.tmp`);
+  let fd;
+  try {
+    mkdirSync12(dirname18(path), { recursive: true, mode: 448 });
+    try {
+      copyFileSync2(path, `${path}.bak`);
+    } catch (error) {
+      if (!isRecord8(error) || error.code !== "ENOENT")
+        throw error;
+    }
+    fd = openSync4(tempPath, "wx", 384);
+    writeFileSync13(fd, `${JSON.stringify(settings)}
+`, "utf8");
+    closeSync4(fd);
+    fd = void 0;
+    renameSync6(tempPath, path);
+    return settings;
+  } catch {
+    return { unavailable: "\u56DE\u8DF3\u8BBE\u7F6E\u5907\u4EFD\u6216\u5199\u5165\u5931\u8D25,\u672A\u8986\u76D6\u8BBE\u7F6E;\u8BF7\u4EBA\u5DE5\u68C0\u67E5 settings.json" };
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync4(fd);
+      } catch {
+      }
+    }
+    try {
+      rmSync10(tempPath, { force: true });
+    } catch {
+    }
+  }
+}
+function isSettings(value) {
+  if (!isRecord8(value) || value.version !== 1 || !Object.keys(value).every((key) => key === "version" || key === "returnTarget")) {
+    return false;
+  }
+  return value.returnTarget === void 0 || isRecord8(value.returnTarget) && Object.keys(value.returnTarget).every((key) => key === "bundlePath") && typeof value.returnTarget.bundlePath === "string" && value.returnTarget.bundlePath.startsWith("/");
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // apps/cli/dist/suggest.js
 init_dist();
@@ -17761,6 +17973,10 @@ async function handle(req, res, options, warn, runtime) {
     await handleTaskOverlay(req, res, options);
     return;
   }
+  if (url.pathname === "/api/return-target" || url.pathname === "/api/return") {
+    await handleReturn(req, res, options, url.pathname === "/api/return");
+    return;
+  }
   if (url.pathname === "/api/license/install" && req.method === "POST") {
     await handleLicenseInstall(req, res, options);
     return;
@@ -17992,6 +18208,64 @@ async function handleActionApply(req, res, options, runtime) {
     sendJson2(res, 400, { error: errorMessage3(error) });
   }
 }
+async function handleReturn(req, res, options, activate) {
+  if (req.method !== "POST" && (activate || req.method !== "GET")) {
+    sendText2(res, 405, "method not allowed");
+    return;
+  }
+  if (req.method === "POST" && options.readonlyActions) {
+    sendJson2(res, 403, { error: "fixtures \u6A21\u5F0F\u53EA\u8BFB:\u4E0D\u4FDD\u5B58\u56DE\u8DF3\u8BBE\u7F6E\u6216\u6FC0\u6D3B\u5E94\u7528" });
+    return;
+  }
+  if (options.homeDir === void 0) {
+    sendJson2(res, 500, { error: "\u56DE\u8DF3\u8BBE\u7F6E\u7F3A\u5C11 homeDir" });
+    return;
+  }
+  const available = detectReturnTargets(options.homeDir, options.returnTargetRoots);
+  if (req.method === "GET") {
+    const settings = readReturnTargetSettings(options.homeDir);
+    sendJson2(res, 200, {
+      available,
+      ..."unavailable" in settings ? { settings } : settings.returnTarget === void 0 ? {} : { selected: settings.returnTarget }
+    });
+    return;
+  }
+  const body = await readJsonBody(req);
+  if (!isRecord9(body) || Object.keys(body).some((key) => key !== "bundlePath") || typeof body.bundlePath !== "string") {
+    sendJson2(res, 400, { error: "\u8BF7\u6C42\u53EA\u63A5\u53D7 bundlePath \u5B57\u7B26\u4E32" });
+    return;
+  }
+  const target = available.find((target2) => target2.bundlePath === body.bundlePath);
+  if (!target) {
+    sendJson2(res, 400, { error: "\u672A\u68C0\u6D4B\u5230\u8BE5\u56DE\u8DF3\u5E94\u7528" });
+    return;
+  }
+  if (!activate) {
+    const settings = saveReturnTarget(options.homeDir, target.bundlePath);
+    if ("unavailable" in settings)
+      sendJson2(res, 409, { error: settings.unavailable });
+    else
+      sendJson2(res, 200, { selected: settings.returnTarget });
+    return;
+  }
+  try {
+    await (options.opener ?? openReturnTarget)(target.bundlePath);
+    sendJson2(res, 200, { activated: true, name: target.name });
+  } catch (error) {
+    const timedOut = isRecord9(error) && (error.killed === true || error.code === "ETIMEDOUT");
+    sendJson2(res, 200, { activated: false, reason: timedOut ? "\u5E94\u7528\u6FC0\u6D3B\u8D85\u65F6" : "\u5E94\u7528\u6FC0\u6D3B\u5931\u8D25" });
+  }
+}
+function openReturnTarget(bundlePath) {
+  return new Promise((resolveOpen, reject) => {
+    execFile2("open", ["-a", bundlePath], { timeout: 5e3 }, (error) => {
+      if (error)
+        reject(error);
+      else
+        resolveOpen();
+    });
+  });
+}
 async function handleTaskOverlay(req, res, options) {
   if (options.readonlyActions) {
     sendJson2(res, 403, { error: "fixtures \u6A21\u5F0F\u53EA\u8BFB:\u4E0D\u5199\u4EFB\u52A1\u5361 overlay" });
@@ -18097,11 +18371,11 @@ function isToggleRequest(value) {
   return o.kind === "toggle" && typeof o.itemId === "string" && typeof o.enable === "boolean";
 }
 function isTaskOverlayRequest(value) {
-  if (!isRecord8(value) || !isHarnessId3(value.harness))
+  if (!isRecord9(value) || !isHarnessId3(value.harness))
     return false;
   if (typeof value.sessionId !== "string" || value.sessionId.trim() === "")
     return false;
-  if (!isRecord8(value.patch))
+  if (!isRecord9(value.patch))
     return false;
   const keys = Object.keys(value.patch);
   if (keys.length === 0 || keys.some((key) => !["title", "pinned", "hidden", "accepted"].includes(key))) {
@@ -18112,7 +18386,7 @@ function isTaskOverlayRequest(value) {
 function isHarnessId3(value) {
   return typeof value === "string" && HARNESS_IDS.includes(value);
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readJsonBody(req) {
@@ -18151,8 +18425,8 @@ async function serveStatic(pathname, res, panelDistDir) {
     return;
   }
   const rel = decoded === "/" ? "/index.html" : decoded;
-  const distDir = resolve10(panelDistDir);
-  const filePath = resolve10(distDir, `.${rel}`);
+  const distDir = resolve11(panelDistDir);
+  const filePath = resolve11(distDir, `.${rel}`);
   if (filePath !== distDir && !filePath.startsWith(distDir + sep2)) {
     sendText2(res, 403, "forbidden");
     return;
@@ -18305,7 +18579,7 @@ async function runServe(args) {
 `);
     }
   }
-  const panelDistDir = panelDist === void 0 ? resolve11(dirname18(fileURLToPath2(import.meta.url)), "../../panel/dist") : resolve11(panelDist);
+  const panelDistDir = panelDist === void 0 ? resolve12(dirname19(fileURLToPath2(import.meta.url)), "../../panel/dist") : resolve12(panelDist);
   const narrative = createNarrativeService({
     followTranscripts: !fixtures,
     homeDir,
@@ -18318,7 +18592,7 @@ async function runServe(args) {
   });
   if (fixtures) {
     try {
-      const raw = readFileSync17(fixturePath("cc", "sessions", "session-todos.jsonl"), "utf8");
+      const raw = readFileSync18(fixturePath("cc", "sessions", "session-todos.jsonl"), "utf8");
       narrative.seedFixture("cc", raw.split("\n"), "MOCK \u2014 fixtures \u6F14\u793A:\u53D9\u4E8B\u6570\u636E\u6765\u81EA packages/fixtures \u7684 session-todos.jsonl \u6837\u4F8B\u4F1A\u8BDD,\u975E\u672C\u673A\u771F\u5B9E transcript\u3002");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);