@justjoshn/pi-pstack 0.0.0-stage → 0.15.36-pi.1

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

@@ -0,0 +1,160 @@
+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

@@ -0,0 +1,67 @@
+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([]);
+});