@moxxy/cli 0.14.2 → 0.14.3

package/dist/bin.js

@@ -3666,6 +3666,107 @@ var init_session = __esm({
     };
   }
 });
+
+// ../core/dist/setup-agent.js
+function resolvePermissions(p3) {
+  if (p3 === "deny")
+    return denyByDefaultResolver;
+  if (p3 === void 0 || p3 === "auto")
+    return autoAllowResolver;
+  return p3;
+}
+function finalText(events) {
+  for (let i2 = events.length - 1; i2 >= 0; i2 -= 1) {
+    const e3 = events[i2];
+    if (e3.type === "assistant_message")
+      return e3.content;
+  }
+  return "";
+}
+function mergePresets(presets) {
+  const plugins = [];
+  const seen = /* @__PURE__ */ new Set();
+  const tools = [];
+  let provider;
+  let cwd2;
+  let permissions;
+  let session;
+  for (const p3 of presets) {
+    for (const pl of p3.plugins ?? []) {
+      if (seen.has(pl.name))
+        continue;
+      seen.add(pl.name);
+      plugins.push(pl);
+    }
+    if (p3.tools)
+      tools.push(...p3.tools);
+    if (!provider && p3.provider)
+      provider = p3.provider;
+    cwd2 ??= p3.cwd;
+    permissions ??= p3.permissions;
+    if (p3.session)
+      session = { ...session, ...p3.session };
+  }
+  return { plugins, tools, provider, cwd: cwd2, permissions, session };
+}
+function setupAgent(input = {}) {
+  const opts = Array.isArray(input) ? mergePresets(input) : input;
+  const session = new Session({
+    cwd: opts.cwd ?? process.cwd(),
+    permissionResolver: resolvePermissions(opts.permissions),
+    ...opts.session
+  });
+  for (const plugin5 of opts.plugins ?? [])
+    session.pluginHost.registerStatic(plugin5);
+  for (const tool of opts.tools ?? [])
+    session.tools.register(tool);
+  if (opts.provider)
+    session.providers.setActive(opts.provider.name, opts.provider.config);
+  const agent = {
+    session,
+    async *stream(prompt, runOpts) {
+      yield* runTurn(session, prompt, runOpts);
+    },
+    async ask(prompt, runOpts) {
+      return finalText(await collectTurn(session, prompt, runOpts));
+    },
+    collect(prompt, runOpts) {
+      return collectTurn(session, prompt, runOpts);
+    },
+    async discover() {
+      await session.pluginHost.discoverAndLoad();
+      return agent;
+    },
+    use(plugin5) {
+      session.pluginHost.registerStatic(plugin5);
+      return agent;
+    },
+    addTool(tool) {
+      session.tools.register(tool);
+      return agent;
+    },
+    removeTool(name) {
+      session.tools.unregister(name);
+      return agent;
+    },
+    setProvider(name, config) {
+      session.providers.setActive(name, config);
+      return agent;
+    },
+    setMode(name) {
+      session.modes.setActive(name);
+      return agent;
+    }
+  };
+  return agent;
+}
+var init_setup_agent = __esm({
+  "../core/dist/setup-agent.js"() {
+    init_session();
+    init_run_turn();
+    init_resolvers();
+  }
+});
 function preferencesPath() {
   return path3.join(os5.homedir(), ".moxxy", "preferences.json");
 }
@@ -4149,6 +4250,45 @@ async function restoreEvents(sessionId, dir = defaultSessionsDir(), logger = cre
   }
   return events;
 }
+async function readEventPage(sessionId, opts, dir = defaultSessionsDir()) {
+  const logPath = path3.join(dir, `${sessionId}.jsonl`);
+  let raw;
+  try {
+    raw = await promises.readFile(logPath, "utf8");
+  } catch {
+    return { events: [], prevCursor: null };
+  }
+  const all = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim())
+      continue;
+    try {
+      all.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return pageEvents(all, opts.before, opts.limit);
+}
+function pageEvents(events, before, limit2) {
+  const cap = Math.max(0, Math.floor(limit2));
+  if (cap === 0 || events.length === 0) {
+    return { events: [], prevCursor: events.length === 0 ? null : before };
+  }
+  let end = events.length;
+  if (before !== null) {
+    end = 0;
+    for (let i2 = 0; i2 < events.length; i2 += 1) {
+      if (events[i2].seq < before)
+        end = i2 + 1;
+      else
+        break;
+    }
+  }
+  const start = Math.max(0, end - cap);
+  const page = events.slice(start, end);
+  const prevCursor = start <= 0 ? null : page[0].seq;
+  return { events: page, prevCursor };
+}
 async function deleteSession(sessionId, dir = defaultSessionsDir()) {
   await promises.rm(path3.join(dir, `${sessionId}.jsonl`), { force: true });
   await promises.rm(metaPath(dir, sessionId), { force: true });
@@ -8414,16 +8554,19 @@ __export(dist_exports, {
   mergeUsageStats: () => mergeUsageStats,
   newSessionId: () => newSessionId,
   newTurnId: () => newTurnId,
+  pageEvents: () => pageEvents,
   parseFrontmatter: () => parseFrontmatter,
   parseSkillFile: () => parseSkillFile,
   parseView: () => parseView,
   permissionPolicySchema: () => permissionPolicySchema,
   preferencesPath: () => preferencesPath,
   readPackageMoxxyRequirements: () => readPackageMoxxyRequirements,
+  readSessionEventPage: () => readEventPage,
   readSessionIndex: () => readIndex,
   restoreSessionEvents: () => restoreEvents,
   runTurn: () => runTurn,
   savePreferences: () => savePreferences,
+  setupAgent: () => setupAgent,
   silentLogger: () => silentLogger,
   synthesizeSkill: () => synthesizeSkill,
   toposortPluginManifests: () => toposortPluginManifests,
@@ -8434,6 +8577,7 @@ var init_dist = __esm({
   "../core/dist/index.js"() {
     init_session();
     init_run_turn();
+    init_setup_agent();
     init_subagents();
     init_preferences();
     init_usage_stats();
@@ -136266,7 +136410,7 @@ async function reclaimStaleSocket(socketPath) {
 
 // ../runner/dist/server.js
 init_dist();
-var RUNNER_PROTOCOL_VERSION = 9;
+var RUNNER_PROTOCOL_VERSION = 10;
 var MIN_COMPATIBLE_PROTOCOL_VERSION = 1;
 var RunnerMethod = {
   /** client->server: handshake; returns the initial info snapshot. */
@@ -136285,6 +136429,13 @@ var RunnerMethod = {
    * attached clients so every mirror clears in lockstep.
    */
   SessionReset: "session.reset",
+  /**
+   * client->server: page the runner's authoritative event history (v10).
+   * `{ before, limit }` → `{ events, prevCursor }`, newest-first. Backs the
+   * desktop dual-history retirement; a v10 client gates it on the server's
+   * reported version and falls back to its NDJSON store against an older runner.
+   */
+  SessionLoadHistory: "session.loadHistory",
   /** client->server: declare which resolvers this client will answer. */
   SetResolver: "setResolver",
   /** client->server: switch the active mode. */
@@ -136410,6 +136561,11 @@ var modeSetActiveParamsSchema = z.object({ name: z.string() });
 var sessionSetReasoningParamsSchema = z.object({
   effort: z.enum(["off", "low", "medium", "high"])
 });
+var MAX_HISTORY_PAGE_LIMIT = 2e3;
+var sessionLoadHistoryParamsSchema = z.object({
+  before: z.number().int().nonnegative().nullable(),
+  limit: z.number().int().positive().max(MAX_HISTORY_PAGE_LIMIT)
+});
 var providerSetActiveParamsSchema = z.object({
   name: z.string(),
   config: z.record(z.unknown()).optional()
@@ -136734,6 +136890,7 @@ async function handleSurfaceClose(ctx, raw) {
 }
 
 // ../runner/dist/handlers/session-handlers.js
+init_dist();
 function handleModeSetActive(ctx, raw) {
   const { name } = modeSetActiveParamsSchema.parse(raw);
   ctx.session.modes.setActive(name);
@@ -136745,6 +136902,14 @@ function handleSessionSetReasoning(ctx, raw) {
   ctx.broadcastInfo();
   return {};
 }
+async function handleSessionLoadHistory(ctx, raw) {
+  const { before, limit: limit2 } = sessionLoadHistoryParamsSchema.parse(raw);
+  const log = ctx.session.log;
+  if (log.baseSeq === 0) {
+    return pageEvents(log.toJSON(), before, limit2);
+  }
+  return readEventPage(String(ctx.session.id), { before, limit: limit2 }, ctx.sessionsDir);
+}
 async function handlePermissionAddAllow(ctx, raw) {
   const { name, reason } = permissionAddAllowParamsSchema.parse(raw);
   await ctx.session.permissions.addAllow({ name, ...reason ? { reason } : {} });
@@ -136863,6 +137028,7 @@ var RunnerServer = class {
     peer.handle(RunnerMethod.RunTurn, (raw) => this.handleRunTurn(client, raw));
     peer.handle(RunnerMethod.Abort, (raw) => this.handleAbort(client, raw));
     peer.handle(RunnerMethod.SessionReset, () => this.handleSessionReset());
+    peer.handle(RunnerMethod.SessionLoadHistory, (raw) => handleSessionLoadHistory(ctx, raw));
     peer.handle(RunnerMethod.SetResolver, (raw) => this.handleSetResolver(client, raw));
     peer.handle(RunnerMethod.ModeSetActive, (raw) => handleModeSetActive(ctx, raw));
     peer.handle(RunnerMethod.SessionSetReasoning, (raw) => handleSessionSetReasoning(ctx, raw));
@@ -136946,6 +137112,7 @@ var RunnerServer = class {
       } finally {
         this.turnControllers.delete(turnId);
         client.turns.delete(turnId);
+        await this.sealUnsealedStreamedText(turnId);
         this.broadcast(RunnerNotification.TurnComplete, {
           turnId,
           ...error2 ? { error: error2 } : {}
@@ -136990,6 +137157,59 @@ var RunnerServer = class {
     this.session.log.clear();
     return {};
   }
+  /**
+   * If this turn streamed assistant text (`assistant_chunk`) that no
+   * `assistant_message` ever sealed, append a REAL `assistant_message` to the
+   * authoritative log so it persists + replays like any other reply. It
+   * accumulates chunk deltas and seals whatever text remains at turn end — so a
+   * cleanly sealed reply (the normal path) leaves an empty remainder and this is
+   * a no-op.
+   *
+   * The accumulator resets on BOTH per-iteration boundaries — an
+   * `assistant_message` (a reply was sealed) AND a `provider_request` (a fresh
+   * provider iteration begins). Resetting on `provider_request` is what scopes
+   * the seal to the FINAL iteration: a retryable provider error can abandon a
+   * partially-streamed iteration WITHOUT sealing it (the mode loop emits the
+   * error and `continue`s), and a later iteration then streams fresh text and
+   * may itself end unsealed (a fatal error / abort / max-iterations). Without
+   * the `provider_request` reset, the abandoned attempt's chunks would be
+   * concatenated INTO the sealed reply ("ABANDONED-final" instead of "final"),
+   * durably corrupting authoritative/replayed history. (This is a deliberate
+   * improvement over the desktop renderer's old turn-complete synthesis, which
+   * accumulated across iterations and had exactly that defect — and which this
+   * seal retires.)
+   *
+   * The append flows through `session.log` → persistence + the broadcast stream,
+   * so mirrors ingest it as a normal event and never need to synthesize their
+   * own.
+   */
+  async sealUnsealedStreamedText(turnId) {
+    const events = this.session.log.byTurn(turnId);
+    if (events.length === 0)
+      return;
+    let unsealed = "";
+    for (const event of events) {
+      if (event.type === "assistant_message" || event.type === "provider_request")
+        unsealed = "";
+      else if (event.type === "assistant_chunk")
+        unsealed += event.delta;
+    }
+    if (!unsealed.trim())
+      return;
+    try {
+      await this.session.log.append({
+        type: "assistant_message",
+        sessionId: this.session.id,
+        turnId,
+        source: "model",
+        content: unsealed,
+        // The turn ended without the provider sealing the message (error/abort
+        // after partial text); record it as a normal completed reply.
+        stopReason: "end_turn"
+      });
+    } catch {
+    }
+  }
   handleSetResolver(client, raw) {
     const params = setResolverParamsSchema.parse(raw);
     if (params.permission !== void 0)
@@ -137602,6 +137822,26 @@ var RemoteSession = class {
   async reset() {
     await this.peer.request(RunnerMethod.SessionReset, {});
   }
+  /**
+   * Page the runner's AUTHORITATIVE event history (protocol v10). Backs the
+   * desktop's dual-history retirement — the renderer reads transcript history
+   * from the runner instead of its own NDJSON chat store. Newest-first paging:
+   * pass `before: null` for the newest page, then feed each result's
+   * `prevCursor` back as `before` to walk older pages until `prevCursor` is
+   * `null` (start of history).
+   *
+   * GATED on the server reporting protocol v10+. Against an OLDER runner this
+   * throws a clear, actionable error (not a raw method-not-found) — the desktop
+   * CATCHES it and falls back to its existing NDJSON path, so no transcript
+   * ever goes blank when the runner predates this method.
+   */
+  async loadHistory(before, limit2) {
+    this.requireServerProtocol(10, "Loading session history from the runner");
+    return this.peer.request(RunnerMethod.SessionLoadHistory, {
+      before,
+      limit: limit2
+    });
+  }
   getInfo() {
     return this.requireInfo();
   }
@@ -145703,8 +145943,8 @@ function runProcess(cmd, args, opts) {
 }
 
 // ../plugin-browser/dist/browser-surface.js
-var FRAME_INTERVAL_MS = 450;
-var FAIL_GRACE = 4;
+var FRAME_INTERVAL_MS = 300;
+var FAIL_GRACE = 6;
 function buildBrowserSurface(deps) {
   return defineSurface({
     kind: "browser",
@@ -145831,9 +146071,10 @@ function buildBrowserSurface(deps) {
           } else if (msg.type === "move" && typeof msg.fx === "number" && typeof msg.fy === "number") {
             await browserSidecarCall("mousemove", { x: msg.fx * vw, y: msg.fy * vh }, deps).catch(() => void 0);
             void tick();
-          } else if (msg.type === "pick" && typeof msg.fx === "number" && typeof msg.fy === "number") {
-            const element = await browserSidecarCall("pick", { x: msg.fx * vw, y: msg.fy * vh }, deps).catch(() => null);
-            emit2({ type: "picked", element });
+          } else if (msg.type === "capture" && typeof msg.fx === "number" && typeof msg.fy === "number" && typeof msg.fw === "number" && typeof msg.fh === "number") {
+            const shot = await browserSidecarCall("capture", { x: msg.fx * vw, y: msg.fy * vh, width: msg.fw * vw, height: msg.fh * vh }, deps).catch(() => null);
+            if (shot)
+              emit2({ type: "captured", base64: shot.base64, mediaType: shot.mediaType });
           } else if (msg.type === "zoom" && typeof msg.factor === "number") {
             await browserSidecarCall("zoom", { factor: msg.factor }, deps).catch(() => void 0);
             bump();