@baique/pi-web-sky 0.1.35 → 0.1.37

package/lib/rpc-manager-shutdown.test.mjs

@@ -0,0 +1,372 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  interopDefault: true,
+  moduleCache: false,
+});
+const { AgentSessionWrapper } = await jiti.import("./rpc-manager.ts");
+
+const nextTurn = () => new Promise((resolve) => setImmediate(resolve));
+
+function makePromptInner(prompt) {
+  return {
+    isBashRunning: false,
+    isStreaming: false,
+    extensionRunner: {},
+    sessionManager: { getCwd: () => "/tmp" },
+    agent: { state: {} },
+    getContextUsage: () => null,
+    getSteeringMessages: () => [],
+    getFollowUpMessages: () => [],
+    prompt,
+    dispose() {},
+  };
+}
+
+test("get_state waits for extension resources before returning the system prompt", async (t) => {
+  let finishBinding;
+  const inner = makePromptInner(() => Promise.resolve());
+  inner.agent.state.systemPrompt = "before extensions";
+  inner.bindExtensions = () => new Promise((resolve) => {
+    finishBinding = () => {
+      inner.agent.state.systemPrompt = "after extensions";
+      resolve();
+    };
+  });
+
+  const wrapper = new AgentSessionWrapper(inner);
+  t.after(() => wrapper.destroy());
+  wrapper.beginExtensionBinding();
+
+  let settled = false;
+  const statePromise = wrapper.send({ type: "get_state" }).then((state) => {
+    settled = true;
+    return state;
+  });
+  await nextTurn();
+
+  assert.equal(settled, false);
+  finishBinding();
+  const state = await statePromise;
+
+  assert.equal(state.systemPrompt, "after extensions");
+});
+
+test("prompt commands wait for SDK preflight acceptance before acknowledging", async (t) => {
+  let acceptPreflight;
+  let finishPrompt;
+  const inner = makePromptInner((_message, options) => new Promise((resolve) => {
+    acceptPreflight = () => options.preflightResult(true);
+    finishPrompt = resolve;
+  }));
+  const wrapper = new AgentSessionWrapper(inner);
+  t.after(() => wrapper.destroy());
+  const events = [];
+  wrapper.onEvent((event) => events.push(event));
+
+  let acknowledged = false;
+  const sending = wrapper.send({ type: "prompt", message: "hello" }).then(() => {
+    acknowledged = true;
+  });
+  await nextTurn();
+
+  assert.equal(acknowledged, false);
+  assert.equal(wrapper.isRunning(), true);
+
+  acceptPreflight();
+  await sending;
+
+  assert.equal(acknowledged, true);
+  assert.equal(wrapper.isRunning(), true);
+  assert.equal(events.some((event) => event.type === "prompt_done"), false);
+
+  finishPrompt();
+  await nextTurn();
+
+  assert.equal(wrapper.isRunning(), false);
+  assert.equal(events.filter((event) => event.type === "prompt_done").length, 1);
+});
+
+test("prompt commands reject when SDK preflight fails", async (t) => {
+  const inner = makePromptInner((_message, options) => {
+    options.preflightResult(false);
+    return Promise.reject(new Error("Authentication failed"));
+  });
+  const wrapper = new AgentSessionWrapper(inner);
+  t.after(() => wrapper.destroy());
+  const events = [];
+  wrapper.onEvent((event) => events.push(event));
+
+  await assert.rejects(
+    wrapper.send({ type: "prompt", message: "hello" }),
+    /Authentication failed/,
+  );
+
+  assert.equal(wrapper.isRunning(), false);
+  assert.deepEqual(events, []);
+});
+
+test("accepted prompt failures still finish through the event stream", async (t) => {
+  let failPrompt;
+  const inner = makePromptInner((_message, options) => {
+    options.preflightResult(true);
+    return new Promise((_resolve, reject) => {
+      failPrompt = () => reject(new Error("post-accept failure"));
+    });
+  });
+  const wrapper = new AgentSessionWrapper(inner);
+  t.after(() => wrapper.destroy());
+  const events = [];
+  wrapper.onEvent((event) => events.push(event));
+
+  await wrapper.send({ type: "prompt", message: "hello" });
+  failPrompt();
+  await nextTurn();
+
+  assert.deepEqual(events.map((event) => event.type), ["prompt_error", "prompt_done"]);
+});
+
+test("queued prompt commands forward their streaming behavior and acknowledge acceptance", async (t) => {
+  let receivedOptions;
+  const inner = makePromptInner((_message, options) => {
+    receivedOptions = options;
+    options.preflightResult(true);
+    return Promise.resolve();
+  });
+  const wrapper = new AgentSessionWrapper(inner);
+  t.after(() => wrapper.destroy());
+  const events = [];
+  wrapper.onEvent((event) => events.push(event));
+
+  await wrapper.send({
+    type: "prompt",
+    message: "next",
+    streamingBehavior: "followUp",
+  });
+  await nextTurn();
+
+  assert.equal(receivedOptions.streamingBehavior, "followUp");
+  assert.equal(receivedOptions.source, "rpc");
+  assert.equal(wrapper.isRunning(), false);
+  assert.deepEqual(events, []);
+});
+
+test("prompt admission waits for the preceding preflight and keeps overlapping runs counted", async (t) => {
+  let callCount = 0;
+  let acceptFirst;
+  let finishFirst;
+  const inner = makePromptInner((_message, options) => {
+    callCount += 1;
+    if (callCount === 1) {
+      return new Promise((resolve) => {
+        acceptFirst = () => {
+          inner.isStreaming = true;
+          options.preflightResult(true);
+        };
+        finishFirst = () => {
+          inner.isStreaming = false;
+          resolve();
+        };
+      });
+    }
+
+    assert.equal(inner.isStreaming, true);
+    options.preflightResult(true);
+    return Promise.resolve();
+  });
+  const wrapper = new AgentSessionWrapper(inner);
+  t.after(() => wrapper.destroy());
+
+  const first = wrapper.send({ type: "prompt", message: "first" });
+  await nextTurn();
+  const queued = wrapper.send({
+    type: "prompt",
+    message: "queued",
+    streamingBehavior: "followUp",
+  });
+  await nextTurn();
+
+  assert.equal(callCount, 1);
+  acceptFirst();
+  await Promise.all([first, queued]);
+  await nextTurn();
+
+  assert.equal(callCount, 2);
+  assert.equal((await wrapper.send({ type: "get_state" })).isPromptRunning, true);
+
+  finishFirst();
+  await nextTurn();
+
+  assert.equal((await wrapper.send({ type: "get_state" })).isPromptRunning, false);
+});
+
+test("prompt admission continues after the preceding preflight rejects", async (t) => {
+  let callCount = 0;
+  let rejectFirst;
+  const inner = makePromptInner((_message, options) => {
+    callCount += 1;
+    if (callCount === 1) {
+      return new Promise((_resolve, reject) => {
+        rejectFirst = () => {
+          options.preflightResult(false);
+          reject(new Error("first rejected"));
+        };
+      });
+    }
+    options.preflightResult(true);
+    return Promise.resolve();
+  });
+  const wrapper = new AgentSessionWrapper(inner);
+  t.after(() => wrapper.destroy());
+
+  const firstRejected = assert.rejects(
+    wrapper.send({ type: "prompt", message: "first" }),
+    /first rejected/,
+  );
+  await nextTurn();
+  const second = wrapper.send({ type: "prompt", message: "second" });
+  await nextTurn();
+  assert.equal(callCount, 1);
+
+  rejectFirst();
+  await Promise.all([firstRejected, second]);
+
+  assert.equal(callCount, 2);
+  assert.equal(wrapper.isRunning(), false);
+});
+
+test("a failing event listener cannot reject prompt completion", async (t) => {
+  const originalConsoleError = console.error;
+  t.after(() => {
+    console.error = originalConsoleError;
+  });
+  console.error = () => {};
+
+  const inner = makePromptInner((_message, options) => {
+    options.preflightResult(true);
+    return Promise.resolve();
+  });
+  const wrapper = new AgentSessionWrapper(inner);
+  t.after(() => wrapper.destroy());
+  const delivered = [];
+  wrapper.onEvent(() => {
+    throw new Error("listener failed");
+  });
+  wrapper.onEvent((event) => delivered.push(event.type));
+
+  await wrapper.send({ type: "prompt", message: "hello" });
+  await nextTurn();
+
+  assert.deepEqual(delivered, ["prompt_done"]);
+  assert.equal(wrapper.isRunning(), false);
+});
+
+test("session shutdown notifies extensions before disposing the SDK session", async () => {
+  const calls = [];
+  const inner = {
+    isBashRunning: false,
+    extensionRunner: {
+      async emit(event) {
+        calls.push(["emit", event]);
+      },
+    },
+    dispose() {
+      calls.push(["dispose"]);
+    },
+  };
+  const wrapper = new AgentSessionWrapper(inner);
+  wrapper.onDestroy(() => calls.push(["destroy"]));
+
+  await Promise.all([wrapper.shutdown(), wrapper.shutdown()]);
+
+  assert.deepEqual(calls, [
+    ["emit", { type: "session_shutdown", reason: "quit" }],
+    ["dispose"],
+    ["destroy"],
+  ]);
+  assert.equal(wrapper.isAlive(), false);
+});
+
+test("session shutdown still disposes the SDK session when an extension fails", async () => {
+  const calls = [];
+  const inner = {
+    isBashRunning: false,
+    extensionRunner: {
+      async emit() {
+        calls.push("emit");
+        throw new Error("shutdown hook failed");
+      },
+    },
+    dispose() {
+      calls.push("dispose");
+    },
+  };
+  const wrapper = new AgentSessionWrapper(inner);
+  wrapper.onDestroy(() => calls.push("destroy"));
+
+  await assert.rejects(wrapper.shutdown(), /shutdown hook failed/);
+
+  assert.deepEqual(calls, ["emit", "dispose", "destroy"]);
+  assert.equal(wrapper.isAlive(), false);
+});
+
+test("direct destruction disposes the SDK session before unregistering the wrapper", () => {
+  const calls = [];
+  const inner = {
+    isBashRunning: false,
+    extensionRunner: {},
+    dispose() {
+      calls.push("dispose");
+    },
+  };
+  const wrapper = new AgentSessionWrapper(inner);
+  wrapper.onDestroy(() => calls.push("destroy"));
+
+  wrapper.destroy();
+  wrapper.destroy();
+
+  assert.deepEqual(calls, ["dispose", "destroy"]);
+  assert.equal(wrapper.isAlive(), false);
+});
+
+test("direct bash commands use sanitized project operations with current shell settings", async (t) => {
+  let received;
+  let shellPath = "/bin/bash";
+  const inner = {
+    isBashRunning: false,
+    isStreaming: false,
+    isCompacting: false,
+    extensionRunner: {},
+    settingsManager: {
+      getShellPath: () => shellPath,
+    },
+    sessionManager: {
+      getCwd: () => process.cwd(),
+      getSessionFile: () => undefined,
+    },
+    agent: { state: {} },
+    getContextUsage: () => null,
+    getSteeringMessages: () => [],
+    getFollowUpMessages: () => [],
+    executeBash: async (command, _onChunk, options) => {
+      received = { command, options };
+      return { output: "", exitCode: 0 };
+    },
+    dispose() {},
+  };
+  const wrapper = new AgentSessionWrapper(inner);
+  t.after(() => wrapper.destroy());
+
+  shellPath = "/custom/bash";
+  await wrapper.send({
+    type: "bash",
+    command: "echo ready",
+    excludeFromContext: true,
+  });
+
+  assert.equal(received.command, "echo ready");
+  assert.equal(received.options.excludeFromContext, true);
+  assert.equal(typeof received.options.operations.exec, "function");
+});

package/lib/rpc-manager-widgets.test.mjs

@@ -0,0 +1,342 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  interopDefault: true,
+  moduleCache: false,
+});
+const { AgentSessionWrapper } = await jiti.import("./rpc-manager.ts");
+
+function makeInner(overrides = {}) {
+  return {
+    sessionId: "widget-test-session",
+    sessionFile: undefined,
+    isStreaming: false,
+    isCompacting: false,
+    isBashRunning: false,
+    autoCompactionEnabled: true,
+    autoRetryEnabled: true,
+    model: undefined,
+    modelRuntime: {
+      getModel: () => undefined,
+      refresh: async () => {},
+    },
+    sessionManager: { getCwd: () => process.cwd() },
+    settingsManager: { setProjectTrusted: () => {} },
+    agent: { state: {} },
+    extensionRunner: {
+      getRegisteredCommands: () => [],
+      setUIContext: () => {},
+      emit: async () => {},
+    },
+    promptTemplates: [],
+    resourceLoader: { getSkills: () => ({ skills: [] }) },
+    subscribe: () => () => {},
+    getContextUsage: () => null,
+    getSteeringMessages: () => [],
+    getFollowUpMessages: () => [],
+    pendingMessageCount: 0,
+    dispose: () => {},
+    reload: async () => {},
+    ...overrides,
+  };
+}
+
+function createContext(overrides = {}) {
+  const events = [];
+  const wrapper = new AgentSessionWrapper(makeInner(overrides));
+  wrapper.onEvent((event) => events.push(event));
+  const context = wrapper.createExtensionUiContext();
+  return { context, events, wrapper };
+}
+
+function widgetEvents(events) {
+  return events.filter((event) => event.type === "extension_ui_request" && event.method === "setWidget");
+}
+
+function snapshot(wrapper) {
+  return wrapper.send({ type: "get_state" }).then((state) => state.extensionWidgets);
+}
+
+test("keeps array widgets compatible while maintaining the state snapshot", async () => {
+  const { context, events, wrapper } = createContext();
+
+  context.setWidget("array", ["one"], { placement: "belowEditor" });
+  assert.deepEqual(widgetEvents(events).at(-1), {
+    type: "extension_ui_request",
+    id: widgetEvents(events).at(-1).id,
+    method: "setWidget",
+    widgetKey: "array",
+    widgetLines: ["one"],
+    widgetPlacement: "belowEditor",
+  });
+  assert.deepEqual(await snapshot(wrapper), [{ key: "array", lines: ["one"], placement: "belowEditor" }]);
+
+  const eventCount = widgetEvents(events).length;
+  context.setWidget("array", ["two"]);
+  assert.equal(widgetEvents(events).length, eventCount + 1);
+  assert.equal(widgetEvents(events).at(-1).widgetLines[0], "two");
+  assert.equal(widgetEvents(events).at(-1).widgetPlacement, undefined);
+  assert.deepEqual(await snapshot(wrapper), [{ key: "array", lines: ["two"], placement: "aboveEditor" }]);
+  wrapper.destroy();
+});
+
+test("renders a factory widget immediately with the fixed headless facade", async () => {
+  const { context, events, wrapper } = createContext();
+  let tui;
+  let theme;
+  const widths = [];
+
+  context.setWidget("factory", (receivedTui, receivedTheme) => {
+    tui = receivedTui;
+    theme = receivedTheme;
+    return {
+      render(width) {
+        widths.push(width);
+        return [`${width}:${tui.terminal.columns}`];
+      },
+    };
+  }, { placement: "belowEditor" });
+
+  const event = widgetEvents(events).at(-1);
+  assert.equal(tui.terminal.columns, 92);
+  assert.equal(tui.terminal.kittyProtocolActive, false);
+  assert.ok(theme);
+  assert.deepEqual(widths, [92]);
+  assert.deepEqual(event.widgetLines, ["92:92"]);
+  assert.equal(event.widgetPlacement, "belowEditor");
+  assert.deepEqual(await snapshot(wrapper), [{ key: "factory", lines: ["92:92"], placement: "belowEditor" }]);
+  wrapper.destroy();
+});
+
+test("requestRender replaces the browser event and server snapshot", async () => {
+  const { context, events, wrapper } = createContext();
+  let tui;
+  let value = "first";
+  context.setWidget("refreshable", (receivedTui) => {
+    tui = receivedTui;
+    return { render: () => [value] };
+  });
+
+  const before = widgetEvents(events).length;
+  value = "second";
+  tui.requestRender();
+  assert.equal(widgetEvents(events).length, before + 1);
+  assert.deepEqual(widgetEvents(events).at(-1).widgetLines, ["second"]);
+  assert.deepEqual(await snapshot(wrapper), [{ key: "refreshable", lines: ["second"], placement: "aboveEditor" }]);
+  wrapper.destroy();
+});
+
+test("clearing and replacing widgets disposes components and invalidates old callbacks", () => {
+  const { context, events, wrapper } = createContext();
+  let oldTui;
+  let oldDisposed = 0;
+  context.setWidget("shared", (tui) => {
+    oldTui = tui;
+    return { render: () => ["old"], dispose: () => { oldDisposed += 1; } };
+  });
+  const beforeReplace = widgetEvents(events).length;
+
+  context.setWidget("shared", ["array"]);
+  assert.equal(oldDisposed, 1);
+  assert.deepEqual(widgetEvents(events).at(-1).widgetLines, ["array"]);
+  const afterReplace = widgetEvents(events).length;
+  oldTui.requestRender();
+  assert.equal(widgetEvents(events).length, afterReplace);
+
+  let newTui;
+  let newDisposed = 0;
+  context.setWidget("shared", (tui) => {
+    newTui = tui;
+    return { render: () => ["new"], dispose: () => { newDisposed += 1; } };
+  });
+  const afterFactoryReplace = widgetEvents(events).length;
+  oldTui.requestRender();
+  assert.equal(widgetEvents(events).length, afterFactoryReplace);
+
+  context.setWidget("shared", undefined);
+  assert.equal(newDisposed, 1);
+  const afterClear = widgetEvents(events).length;
+  newTui.requestRender();
+  assert.equal(widgetEvents(events).length, afterClear);
+  assert.equal(widgetEvents(events).at(-1).widgetLines, undefined);
+  assert.ok(beforeReplace < afterReplace);
+  wrapper.destroy();
+});
+
+test("isolates factory and render failures with a clear and extension_error", async () => {
+  const { context, events, wrapper } = createContext();
+  context.setWidget("factory-error", () => {
+    throw new Error("factory failed");
+  });
+  assert.equal(widgetEvents(events).at(-1).widgetLines, undefined);
+  assert.equal(events.at(-1).type, "extension_error");
+  assert.match(events.at(-1).error, /factory failed/);
+  assert.deepEqual(await snapshot(wrapper), []);
+
+  context.setWidget("factory-error", () => ({ render: () => ["recovered"] }));
+  assert.deepEqual(await snapshot(wrapper), [{ key: "factory-error", lines: ["recovered"], placement: "aboveEditor" }]);
+  context.setWidget("factory-error", undefined);
+
+  context.setWidget("invalid-component", () => ({
+    dispose: () => { throw new Error("dispose failed"); },
+  }));
+  assert.equal(widgetEvents(events).at(-1).widgetLines, undefined);
+  assert.match(events.at(-1).error, /render\(width\)/);
+  assert.deepEqual(await snapshot(wrapper), []);
+
+  let disposed = 0;
+  context.setWidget("render-error", () => ({
+    render: () => { throw new Error("render failed"); },
+    dispose: () => { disposed += 1; },
+  }));
+  assert.equal(disposed, 1);
+  assert.equal(widgetEvents(events).at(-1).widgetLines, undefined);
+  assert.match(events.at(-1).error, /render failed/);
+  assert.deepEqual(await snapshot(wrapper), []);
+
+  context.setWidget("invalid-lines", () => ({ render: () => ["ok", 7] }));
+  assert.equal(widgetEvents(events).at(-1).widgetLines, undefined);
+  assert.match(events.at(-1).error, /string\[\]/);
+  assert.deepEqual(await snapshot(wrapper), []);
+
+  let tui;
+  let shouldThrow = false;
+  context.setWidget("late-render", (receivedTui) => {
+    tui = receivedTui;
+    return {
+      render: () => {
+        if (shouldThrow) throw new Error("late render failed");
+        return ["live"];
+      },
+    };
+  });
+  shouldThrow = true;
+  tui.requestRender();
+  assert.equal(widgetEvents(events).at(-1).widgetLines, undefined);
+  assert.match(events.at(-1).error, /late render failed/);
+  assert.deepEqual(await snapshot(wrapper), []);
+  wrapper.destroy();
+});
+
+test("reload and destroy dispose factory components and invalidate callbacks", async () => {
+  const reloads = [];
+  const { context, events, wrapper } = createContext({
+    reload: async (options) => {
+      reloads.push(options);
+    },
+  });
+  let tui;
+  let disposed = 0;
+  context.setWidget("lifecycle", (receivedTui) => {
+    tui = receivedTui;
+    return { render: () => ["live"], dispose: () => { disposed += 1; } };
+  });
+
+  await wrapper.send({ type: "reload" });
+  assert.equal(disposed, 1);
+  assert.equal(reloads.length, 1);
+  assert.deepEqual(await snapshot(wrapper), []);
+  const afterReload = widgetEvents(events).length;
+  tui.requestRender();
+  assert.equal(widgetEvents(events).length, afterReload);
+
+  let replacementTui;
+  context.setWidget("lifecycle", (receivedTui) => {
+    replacementTui = receivedTui;
+    return { render: () => ["replacement"], dispose: () => { disposed += 1; } };
+  });
+  wrapper.destroy();
+  assert.equal(disposed, 2);
+  const afterDestroy = widgetEvents(events).length;
+  replacementTui.requestRender();
+  assert.equal(widgetEvents(events).length, afterDestroy);
+});
+
+test("command-context reload also clears factory widgets", async () => {
+  const { context, wrapper } = createContext();
+  let disposed = 0;
+  context.setWidget("command-reload", () => ({
+    render: () => ["live"],
+    dispose: () => { disposed += 1; },
+  }));
+
+  await wrapper.createExtensionCommandContextActions().reload();
+  assert.equal(disposed, 1);
+  assert.deepEqual(await snapshot(wrapper), []);
+  wrapper.destroy();
+});
+
+test("dispose-time reentrant updates remain authoritative", async () => {
+  const { context, events, wrapper } = createContext();
+  let replacementTui;
+
+  context.setWidget("reentrant", () => ({
+    render: () => ["old"],
+    dispose: () => {
+      context.setWidget("reentrant", (tui) => {
+        replacementTui = tui;
+        return { render: () => ["replacement"] };
+      });
+    },
+  }));
+
+  context.setWidget("reentrant", ["outer"]);
+  assert.deepEqual(await snapshot(wrapper), [{
+    key: "reentrant",
+    lines: ["replacement"],
+    placement: "aboveEditor",
+  }]);
+
+  const beforeRefresh = widgetEvents(events).length;
+  replacementTui.requestRender();
+  assert.equal(widgetEvents(events).length, beforeRefresh + 1);
+  assert.deepEqual(widgetEvents(events).at(-1).widgetLines, ["replacement"]);
+  context.setWidget("reentrant", undefined);
+  wrapper.destroy();
+});
+
+test("render failure does not clear a dispose-time recovery widget", async () => {
+  const { context, wrapper } = createContext();
+
+  context.setWidget("render-recovery", () => ({
+    render: () => { throw new Error("render failed"); },
+    dispose: () => context.setWidget("render-recovery", ["recovered"]),
+  }));
+
+  assert.deepEqual(await snapshot(wrapper), [{
+    key: "render-recovery",
+    lines: ["recovered"],
+    placement: "aboveEditor",
+  }]);
+  wrapper.destroy();
+});
+
+test("ignores factory registrations after the wrapper is destroyed", () => {
+  const { context, events, wrapper } = createContext();
+  let factoryCalls = 0;
+
+  wrapper.destroy();
+  const before = events.length;
+  context.setWidget("late", () => {
+    factoryCalls += 1;
+    return { render: () => ["late"] };
+  });
+
+  assert.equal(factoryCalls, 0);
+  assert.equal(events.length, before);
+});
+
+test("reload ignores widget registrations triggered by component disposal", async () => {
+  const { context, wrapper } = createContext();
+
+  context.setWidget("reload-source", () => ({
+    render: () => ["live"],
+    dispose: () => context.setWidget("reload-stale", () => ({ render: () => ["stale"] })),
+  }));
+
+  await wrapper.send({ type: "reload" });
+  assert.deepEqual(await snapshot(wrapper), []);
+  wrapper.destroy();
+});