@justjoshn/pi-pstack 0.15.36-pi.1 → 0.15.36-pi.7

package/test/e2e/lifecycle.e2e.test.ts

@@ -1,99 +0,0 @@
-import { afterEach, beforeEach, expect, test } from 'vitest';
-import { contentText, makeSandbox, type PiEvent, type RpcSession, type Sandbox, script, startRpc } from './harness.ts';
-
-let sandbox: Sandbox;
-let rpc: RpcSession;
-beforeEach(() => {
-  sandbox = makeSandbox();
-  rpc = startRpc(sandbox, ['--no-session']);
-});
-afterEach(async () => {
-  await rpc.close();
-  sandbox.dispose();
-});
-
-// Pi sets process.title to "pi", so ps cannot find a child by its arguments; the Task details carry its pid.
-const alive = (pid: number) => {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-async function gone(pids: readonly number[], timeoutMs = 12_000): Promise<boolean> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (pids.every((pid) => !alive(pid))) return true;
-    await new Promise<void>((resolve) => setImmediate(resolve));
-  }
-  return pids.every((pid) => !alive(pid));
-}
-
-async function reply(message: string): Promise<string> {
-  const mark = rpc.events.length;
-  rpc.send({ type: 'prompt', message });
-  await rpc.waitFor((event) => event.type === 'agent_settled' && rpc.events.indexOf(event) >= mark);
-  const last = rpc.events
-    .slice(mark)
-    .filter((event) => event.type === 'message_end' && (event['message'] as { role: string }).role === 'assistant')
-    .at(-1);
-  if (last === undefined) throw new Error('the run produced no assistant message');
-  return contentText((last['message'] as { content: { type: string; text?: string }[] }).content);
-}
-
-async function backgroundAgent(): Promise<number> {
-  const mark = rpc.events.length;
-  rpc.send({ type: 'prompt', message: script([{ tool: 'Task', args: { description: 'slow', prompt: 'go\n@@sleep 60000 SLOW', run_in_background: true } }]) });
-  const end = await rpc.waitFor((event: PiEvent) => event.type === 'tool_execution_end' && event['toolName'] === 'Task' && rpc.events.indexOf(event) >= mark);
-  await rpc.waitFor((event) => event.type === 'agent_settled' && rpc.events.indexOf(event) >= mark);
-  return (end['result'] as { details: { pid: number } }).details.pid;
-}
-
-// Interactive Pi redraws the chat between the old session's shutdown and the new session's start, so a warning sent
-// at shutdown never reaches the screen. The new session's mode status marks that start.
-test.for([
-  { replace: 'new session', command: { type: 'new_session' }, reason: 'new' },
-  { replace: 'reload', command: { type: 'prompt', message: '/test-reload' }, reason: 'reload' },
-])('a $replace shows the stopped-subagent warning after the next session starts', async ({ command, reason }) => {
-  await backgroundAgent();
-  const mark = rpc.events.length;
-  rpc.send({ id: 'replace', ...command });
-  await rpc.waitFor((event) => event['id'] === 'replace');
-  const after = rpc.events.slice(mark);
-  const isUi = (event: PiEvent, method: string) => event.type === 'extension_ui_request' && event['method'] === method;
-  const started = after.findIndex((event) => isUi(event, 'setStatus') && event['statusKey'] === 'pstack-mode');
-  const warned = await rpc.waitFor((event) => isUi(event, 'notify') && String(event['message']).startsWith('Stopped 1 background') && rpc.events.indexOf(event) >= mark);
-  expect([warned['message'], rpc.events.indexOf(warned) - mark > started, started >= 0]).toEqual([`Stopped 1 background subagent (session ${reason}). Resume one with its agent ID.`, true, true]);
-});
-
-test('/reload keeps aliases and tools, and stops the old runtime children (PKG-002)', async () => {
-  const pid = await backgroundAgent();
-  expect(alive(pid)).toBe(true);
-  rpc.send({ id: 'reload', type: 'prompt', message: '/test-reload' });
-  await rpc.waitFor((event) => event['id'] === 'reload');
-  expect(await gone([pid])).toBe(true);
-  expect(await reply('/how @@say STILL-ALIASED')).toBe('STILL-ALIASED');
-  expect(
-    (await reply('tools\n@@tools-list'))
-      .split(',')
-      .filter((name) => name === 'Task' || name === 'TodoWrite')
-      .toSorted(),
-  ).toEqual(['Task', 'TodoWrite']);
-});
-
-test('a new session resets mode and todos and stops the old children (PKG-002)', async () => {
-  rpc.send({ id: 'mode', type: 'prompt', message: '/mode tdd' });
-  await rpc.waitFor((event) => event['id'] === 'mode');
-  await reply(script([{ tool: 'TodoWrite', args: { merge: false, todos: [{ id: 'a', content: 'Alpha', status: 'pending' }] } }]));
-  const pid = await backgroundAgent();
-  expect(alive(pid)).toBe(true);
-  rpc.send({ id: 'new', type: 'new_session' });
-  await rpc.waitFor((event) => event['id'] === 'new');
-  expect(await gone([pid])).toBe(true);
-  const notice = rpc.events.find((event) => event.type === 'extension_ui_request' && event['method'] === 'notify' && String(event['message']).startsWith('Stopped 1 background'));
-  expect(notice?.['message']).toBe('Stopped 1 background subagent (session new). Resume one with its agent ID.');
-  expect(await reply('fresh\n@@sys')).not.toContain('<pstack_mode>');
-  expect(await reply(script([{ tool: 'TodoWrite', args: { merge: true, todos: [{ id: 'b', content: 'Beta', status: 'pending' }] } }]))).toBe('RESULTS:\n[TodoWrite] Todos (0/1 completed):\n[ ] b: Beta');
-});

package/test/e2e/mode.e2e.test.ts

@@ -1,160 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, expect, test } from 'vitest';
-import { PACKAGE_ROOT } from '../../src/paths.ts';
-import { contentText, makeSandbox, type PiEvent, type RpcSession, type Sandbox, startRpc } from './harness.ts';
-
-let sandbox: Sandbox;
-beforeEach(() => {
-  sandbox = makeSandbox();
-});
-afterEach(() => sandbox.dispose());
-
-async function ask(rpc: RpcSession, message: string): Promise<string> {
-  const mark = rpc.events.length;
-  rpc.send({ type: 'prompt', message });
-  await rpc.waitFor((event) => event.type === 'agent_settled' && rpc.events.indexOf(event) >= mark);
-  const reply = rpc.events
-    .slice(mark)
-    .filter((event) => event.type === 'message_end' && (event['message'] as { role: string }).role === 'assistant')
-    .at(-1);
-  if (reply === undefined) throw new Error('the run produced no assistant message');
-  return contentText((reply['message'] as { content: { type: string; text?: string }[] }).content);
-}
-
-async function command(rpc: RpcSession, message: string): Promise<PiEvent> {
-  const id = `cmd-${rpc.events.length}`;
-  rpc.send({ id, type: 'prompt', message });
-  return rpc.waitFor((event) => event['id'] === id);
-}
-
-const modeSectionOf = (prompt: string) => /<pstack_mode>\n([\s\S]*?)\n<\/pstack_mode>/.exec(prompt)?.[1];
-const statuses = (rpc: RpcSession) => rpc.events.filter((event) => event.type === 'extension_ui_request' && event['method'] === 'setStatus' && event['statusKey'] === 'pstack-mode').map((event) => event['statusText']);
-
-test('/mode keeps the skill on every turn until /mode off, with a status badge (MODE-001, MODE-002, MODE-005)', async () => {
-  const rpc = startRpc(sandbox, ['--no-session']);
-  try {
-    const mark = rpc.events.length;
-    rpc.send({ type: 'prompt', message: '/mode poteto-mode first task\n@@sys' });
-    await rpc.waitFor((event) => event.type === 'agent_settled' && rpc.events.indexOf(event) >= mark);
-    const firstUser = rpc.events.find((event) => event.type === 'message_end' && (event['message'] as { role: string }).role === 'user');
-    if (firstUser === undefined) throw new Error('no user message');
-    expect(contentText((firstUser['message'] as { content: string }).content)).toBe('first task\n@@sys');
-    const firstReply = rpc.events.find((event) => event.type === 'message_end' && (event['message'] as { role: string }).role === 'assistant');
-    if (firstReply === undefined) throw new Error('no assistant reply');
-    expect(modeSectionOf(contentText((firstReply['message'] as { content: { type: string; text?: string }[] }).content))?.split('\n')[0]).toBe('Mode poteto-mode is on for every turn until the user runs /mode off.');
-    expect(statuses(rpc).some((text) => typeof text === 'string' && text.replace(/\x1b\[[0-9;]*m/g, '') === '♛ mode: poteto-mode')).toBe(true);
-
-    const second = modeSectionOf(await ask(rpc, 'second turn\n@@sys'));
-    expect(second?.startsWith('Mode poteto-mode is on for every turn until the user runs /mode off.\n<skill name="poteto-mode"')).toBe(true);
-    expect(second).not.toContain('New task?');
-    expect(second).toContain('# Poteto mode\n\nBundled skills live at `../<name>/SKILL.md` from this file');
-    // The absolute path that 0.15.21's poteto-mode tells the parent to hand each poteto-agent (RES-010).
-    expect(second).toContain(`<skill name="poteto-mode" location="${join(PACKAGE_ROOT, 'skills/poteto-mode/SKILL.md')}">`);
-
-    await command(rpc, '/mode off');
-    expect(modeSectionOf(await ask(rpc, 'third turn\n@@sys'))).toBeUndefined();
-    expect(statuses(rpc).at(-1)).toBeUndefined();
-  } finally {
-    await rpc.close();
-  }
-});
-
-test('the /mode task goes through normal skill expansion (MODE-001)', async () => {
-  const rpc = startRpc(sandbox, ['--no-session']);
-  try {
-    const mark = rpc.events.length;
-    rpc.send({ type: 'prompt', message: '/mode tdd /ketchup since lunch\n@@say OK' });
-    await rpc.waitFor((event) => event.type === 'agent_settled' && rpc.events.indexOf(event) >= mark);
-    const user = rpc.events.find((event) => event.type === 'message_end' && (event['message'] as { role: string }).role === 'user');
-    if (user === undefined) throw new Error('no user message');
-    const text = contentText((user['message'] as { content: string }).content);
-    expect([text.startsWith('<skill name="ketchup"'), text.endsWith('since lunch\n@@say OK')]).toEqual([true, true]);
-  } finally {
-    await rpc.close();
-  }
-});
-
-test('/mode rejects an unknown skill and lists the choices (MODE-002)', async () => {
-  const rpc = startRpc(sandbox, ['--no-session']);
-  try {
-    await command(rpc, '/mode no-such-skill');
-    const notice = await rpc.waitFor((event) => event.type === 'extension_ui_request' && event['method'] === 'notify');
-    expect(notice['notifyType']).toBe('error');
-    expect(String(notice['message'])).toMatch(/^No skill named "no-such-skill"\. Skills that can back a mode: architect, arena, /);
-  } finally {
-    await rpc.close();
-  }
-});
-
-test('a mode whose stored skill path went stale is found again by name (recheck 4)', async () => {
-  const sessions = join(sandbox.root, 'sessions');
-  const first = startRpc(sandbox, ['--session-dir', sessions]);
-  let sessionFile = '';
-  try {
-    await command(first, '/mode tdd');
-    first.send({ id: 'state', type: 'get_state' });
-    sessionFile = String(((await first.waitFor((event) => event['id'] === 'state'))['data'] as { sessionFile: string }).sessionFile);
-    await ask(first, 'persist\n@@say OK');
-  } finally {
-    await first.close();
-  }
-  const moved = readFileSync(sessionFile, 'utf8').replaceAll(join(PACKAGE_ROOT, 'skills/tdd/SKILL.md'), '/old/install/skills/tdd/SKILL.md');
-  expect(moved).toContain('/old/install/skills/tdd/SKILL.md');
-  writeFileSync(sessionFile, moved);
-  const second = startRpc(sandbox, ['--session-dir', sessions, '--session', sessionFile]);
-  try {
-    const section = modeSectionOf(await ask(second, 'after the move\n@@sys'));
-    expect(section?.split('\n').slice(0, 2)).toEqual(['Mode tdd is on for every turn until the user runs /mode off.', `<skill name="tdd" location="${join(PACKAGE_ROOT, 'skills/tdd/SKILL.md')}">`]);
-  } finally {
-    await second.close();
-  }
-});
-
-test('a stored mode whose skill no longer loads never inlines the stored path (review r2: security 3)', async () => {
-  const sessions = join(sandbox.root, 'sessions');
-  const secret = join(sandbox.root, 'secret.txt');
-  writeFileSync(secret, '---\nname: x\n---\nSECRET-CONTENT\n');
-  const first = startRpc(sandbox, ['--session-dir', sessions]);
-  let sessionFile = '';
-  try {
-    await command(first, '/mode tdd');
-    first.send({ id: 'state', type: 'get_state' });
-    sessionFile = String(((await first.waitFor((event) => event['id'] === 'state'))['data'] as { sessionFile: string }).sessionFile);
-    await ask(first, 'persist\n@@say OK');
-  } finally {
-    await first.close();
-  }
-  // A crafted or pre-0.15.20 entry that names a path, as an untrusted session file could.
-  const crafted = readFileSync(sessionFile, 'utf8').replace(/"data":\{"skill":"tdd"[^}]*\}/, `"data":${JSON.stringify({ skill: 'gone-skill', path: secret })}`);
-  expect(crafted).toContain(`"path":${JSON.stringify(secret)}`);
-  writeFileSync(sessionFile, crafted);
-  const second = startRpc(sandbox, ['--session-dir', sessions, '--session', sessionFile]);
-  try {
-    const section = modeSectionOf(await ask(second, 'after\n@@sys'));
-    expect(section).toBe('Mode gone-skill is on, but no loaded skill has that name. Tell the user to run /mode off or /mode <skill>.');
-  } finally {
-    await second.close();
-  }
-});
-
-test('the mode survives a restart of the same session (MODE-003)', async () => {
-  const sessions = join(sandbox.root, 'sessions');
-  const first = startRpc(sandbox, ['--session-dir', sessions]);
-  let sessionFile = '';
-  try {
-    await command(first, '/mode tdd');
-    expect(modeSectionOf(await ask(first, 'check\n@@sys'))?.split('\n')[0]).toBe('Mode tdd is on for every turn until the user runs /mode off.');
-    first.send({ id: 'state', type: 'get_state' });
-    sessionFile = String(((await first.waitFor((event) => event['id'] === 'state'))['data'] as { sessionFile: string }).sessionFile);
-  } finally {
-    await first.close();
-  }
-  const second = startRpc(sandbox, ['--session-dir', sessions, '--session', sessionFile]);
-  try {
-    expect(modeSectionOf(await ask(second, 'after restart\n@@sys'))?.split('\n')[0]).toBe('Mode tdd is on for every turn until the user runs /mode off.');
-  } finally {
-    await second.close();
-  }
-});

package/test/e2e/package.e2e.test.ts

@@ -1,67 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { cpSync, existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-import { afterEach, beforeEach, expect, test } from 'vitest';
-import { PACKAGE_ROOT } from '../../src/paths.ts';
-import { contentText, makeSandbox, piInvocation, runJson, type Sandbox, script, startRpc, toolEnds } from './harness.ts';
-
-let sandbox: Sandbox;
-beforeEach(() => {
-  sandbox = makeSandbox({ packages: [] });
-});
-afterEach(() => sandbox.dispose());
-
-const pi = (...args: string[]) => execFileSync(...piInvocation(args), { cwd: sandbox.workDir, env: sandbox.env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-const settingsPackages = () => ((JSON.parse(readFileSync(join(sandbox.agentDir, 'settings.json'), 'utf8')) as { packages?: string[] }).packages ?? []).map((entry) => resolve(sandbox.agentDir, entry));
-
-async function discovered(): Promise<{ commands: string[]; tools: string }> {
-  const rpc = startRpc(sandbox, ['--no-session']);
-  try {
-    rpc.send({ id: 'commands', type: 'get_commands' });
-    const response = await rpc.waitFor((event) => event['id'] === 'commands');
-    const commands = ((response['data'] as { commands: { name: string }[] }).commands ?? []).map((command) => command.name);
-    rpc.send({ type: 'prompt', message: 'list\n@@tools-list' });
-    const reply = await rpc.waitFor((event) => event.type === 'message_end' && (event['message'] as { role: string }).role === 'assistant');
-    return { commands, tools: contentText((reply['message'] as { content: { type: string; text?: string }[] }).content) };
-  } finally {
-    await rpc.close();
-  }
-}
-
-test('installs from a fresh copy without node_modules, then removes cleanly (PKG-001)', async () => {
-  const copy = join(sandbox.root, 'pi-pstack');
-  cpSync(PACKAGE_ROOT, copy, { recursive: true, filter: (source) => !/\/(node_modules|coverage)(\/|$)/.test(source.slice(PACKAGE_ROOT.length)) });
-  expect(existsSync(join(copy, 'node_modules'))).toBe(false);
-
-  pi('install', copy);
-  expect(settingsPackages()).toEqual([copy]);
-  const installed = await discovered();
-  expect(installed.commands.filter((name) => ['mode', 'loop', 'skill:poteto-mode', 'skill:how', 'skill:create-skill', 'skill:deslop'].includes(name)).toSorted()).toEqual([
-    'loop',
-    'mode',
-    'skill:create-skill',
-    'skill:deslop',
-    'skill:how',
-    'skill:poteto-mode',
-  ]);
-  expect(installed.commands.filter((name) => name.startsWith('skill:'))).toHaveLength(62);
-  expect(
-    installed.tools
-      .split(',')
-      .filter((name) => ['Task', 'TodoWrite', 'AskQuestion', 'Loop'].includes(name))
-      .toSorted(),
-  ).toEqual(['AskQuestion', 'Loop', 'Task', 'TodoWrite']);
-
-  // A local install gets no dependency install, so the readonly shell has no sandbox module and must refuse (TASK-019).
-  const steps = [{ tool: 'bash', args: { command: 'touch escaped.txt' } }];
-  const readonlyRun = await runJson(sandbox, script([{ tool: 'Task', args: { description: 'ro', prompt: `go\n@@script ${JSON.stringify(steps)}`, readonly: true } }]), ['--no-session']);
-  expect(toolEnds(readonlyRun.events, 'Task')[0]?.text).toContain('no verified OS sandbox is available');
-  expect(existsSync(join(sandbox.workDir, 'escaped.txt'))).toBe(false);
-
-  pi('remove', copy);
-  expect(settingsPackages()).toEqual([]);
-  const removed = await discovered();
-  expect(removed.commands.filter((name) => name === 'mode' || name.startsWith('skill:'))).toEqual([]);
-  expect(removed.tools.split(',').filter((name) => ['Task', 'TodoWrite'].includes(name))).toEqual([]);
-});