2026-09-28 19:37:41 -07:00
// Tests for the global `plan2code` launcher. Run with: node --test scripts/test-launcher.mjs
//
// The launcher is a script that runs on load, so each test spawns it for real: a temp home
2026-10-11 16:39:25 -07:00
// for ~/.plan2code/launcher.json, and stand-in `claude` / `devin` / `codex` commands on PATH that
2026-09-28 19:37:41 -07:00
// record the arguments they were started with. stdin is a pipe, never a TTY, so the launcher
// takes its no-prompt path: no menu and no wait at the model notice.
import test from "node:test" ;
import assert from "node:assert/strict" ;
import fs from "node:fs" ;
import os from "node:os" ;
import path from "node:path" ;
import { spawnSync } from "node:child_process" ;
2026-10-02 20:51:34 -07:00
import { createRequire } from "node:module" ;
2026-09-28 19:37:41 -07:00
import { fileURLToPath } from "node:url" ;
2026-10-02 20:51:34 -07:00
const require = createRequire ( import . meta . url );
2026-09-28 19:37:41 -07:00
const ROOT = path . resolve ( path . dirname ( fileURLToPath ( import . meta . url )), ".." );
const LAUNCHER = path . join ( ROOT , "src" , "launcher" , "plan2code.js" );
const IS_WINDOWS = process . platform === "win32" ;
const NOTICE = "will use the model you last used in it" ;
2026-10-16 19:28:11 -07:00
/**
* A temp home and a bin dir holding stand-ins for `clis`; each writes its args to <bin>/<cli>.json.
* `installed: "X.Y.Z"` runs an installed copy instead, as install.js lays it out: the launcher,
2026-11-03 03:21:20 -08:00
* models.json, update-check.mjs, agents.json and agent-lookup.mjs in <home>/.plan2code/bin/
* beside a version.json saying X.Y.Z (`lookup: false` leaves agent-lookup.mjs out, `agents`
* replaces agents.json's contents).
2026-10-16 19:28:11 -07:00
*/
2026-11-03 03:21:20 -08:00
function sandbox ( clis , { installed , project = true , lookup = true , agents } = {}) {
2026-09-28 19:37:41 -07:00
const dir = fs . mkdtempSync ( path . join ( os . tmpdir (), "p2c-launcher-" ));
2026-10-23 10:04:13 -07:00
// `dir` is the launcher's cwd below; mark it as a project so the project-confirmation gate
// does not fire in every other test here. The gate's own tests pass `project: false`.
if ( project ) fs . writeFileSync ( path . join ( dir , "AGENTS.md" ), "" );
2026-09-28 19:37:41 -07:00
const home = path . join ( dir , "home" );
const bin = path . join ( dir , "bin" );
fs . mkdirSync ( home );
fs . mkdirSync ( bin );
2026-10-16 19:28:11 -07:00
const consoleHome = path . join ( home , ".plan2code" , "console" );
let launcher = LAUNCHER ;
if ( installed ) {
const binCopy = path . join ( home , ".plan2code" , "bin" );
fs . mkdirSync ( binCopy , { recursive : true });
launcher = path . join ( binCopy , "plan2code.js" );
fs . copyFileSync ( LAUNCHER , launcher );
fs . copyFileSync ( path . join ( path . dirname ( LAUNCHER ), "models.json" ), path . join ( binCopy , "models.json" ));
fs . copyFileSync ( path . join ( ROOT , "src" , "web-console" , "update-check.mjs" ), path . join ( binCopy , "update-check.mjs" ));
2026-11-03 03:21:20 -08:00
const agentsFile = agents || path . join ( path . dirname ( LAUNCHER ), "agents.json" );
if ( typeof agentsFile === "string" && fs . existsSync ( agentsFile )) fs . copyFileSync ( agentsFile , path . join ( binCopy , "agents.json" ));
else if ( agentsFile ) fs . writeFileSync ( path . join ( binCopy , "agents.json" ), JSON . stringify ( agentsFile ));
if ( lookup ) fs . copyFileSync ( path . join ( ROOT , "src" , "web-console" , "agent-lookup.mjs" ), path . join ( binCopy , "agent-lookup.mjs" ));
2026-10-16 19:28:11 -07:00
fs . writeFileSync ( path . join ( binCopy , "version.json" ), JSON . stringify ({ name : "Plan2Code" , version : installed }));
}
2026-09-28 19:37:41 -07:00
const recorder = path . join ( bin , "record.js" );
fs . writeFileSync (
recorder ,
'require("fs").writeFileSync(require("path").join(__dirname, process.argv[2] + ".json"), JSON.stringify(process.argv.slice(3)));\n' +
"process.exitCode = Number(process.env.P2C_TEST_EXIT || 0);\n"
);
for ( const cli of clis ) {
if ( IS_WINDOWS ) {
fs . writeFileSync ( path . join ( bin , ` ${ cli } .cmd` ), `@" ${ process . execPath } " " ${ recorder } " ${ cli } %*\r\n` );
} else {
const file = path . join ( bin , cli );
fs . writeFileSync ( file , `#!/bin/sh\nexec " ${ process . execPath } " " ${ recorder } " ${ cli } "$@"\n` );
fs . chmodSync ( file , 0o755 );
}
}
2026-10-23 10:04:13 -07:00
// A stand-in for the desktop app that records its arguments like the CLIs do. It is not
// on PATH: the launcher finds it through PLAN2CODE_APP, set only for the run that wants it.
const appDir = path . join ( dir , "app" );
fs . mkdirSync ( appDir );
const appFile = path . join ( appDir , IS_WINDOWS ? "stand-in-app.cmd" : "stand-in-app" );
if ( IS_WINDOWS ) {
// The first line leaves the sandbox folder (the app's working directory) so nothing holds it open.
fs . writeFileSync ( appFile , `@cd /d " ${ os . tmpdir () } "\r\n@" ${ process . execPath } " " ${ recorder } " app %*\r\n` );
} else {
fs . writeFileSync ( appFile , `#!/bin/sh\ncd " ${ os . tmpdir () } " && exec " ${ process . execPath } " " ${ recorder } " app "$@"\n` );
fs . chmodSync ( appFile , 0o755 );
}
// One that starts and dies at once, as a program with a missing system library does.
const crashFile = path . join ( appDir , IS_WINDOWS ? "crashing-app.cmd" : "crashing-app" );
if ( IS_WINDOWS ) {
fs . writeFileSync ( crashFile , "@exit /b 3\r\n" );
} else {
fs . writeFileSync ( crashFile , "#!/bin/sh\nexit 3\n" );
fs . chmodSync ( crashFile , 0o755 );
}
2026-09-28 19:37:41 -07:00
return {
2026-10-23 10:04:13 -07:00
dir ,
2026-09-28 19:37:41 -07:00
home ,
2026-10-23 10:04:13 -07:00
appFile ,
crashFile ,
2026-09-28 19:37:41 -07:00
stateFile : path . join ( home , ".plan2code" , "launcher.json" ),
2026-10-16 19:28:11 -07:00
cacheFile : path . join ( consoleHome , "update-check.json" ),
2026-09-28 19:37:41 -07:00
run : ( args , env = {}) =>
2026-10-16 19:28:11 -07:00
spawnSync ( process . execPath , [ launcher , ... args ], {
2026-09-28 19:37:41 -07:00
cwd : dir ,
input : "" ,
encoding : "utf8" ,
2026-10-27 21:48:43 -07:00
env : { ... process . env , PATH : bin , PLAN2CODE_NO_SAVED_PATH : "1" , HOME : home , USERPROFILE : home , PLAN2CODE_CONSOLE_HOME : consoleHome , ... env },
2026-09-28 19:37:41 -07:00
}),
argsOf : ( cli ) => {
const file = path . join ( bin , ` ${ cli } .json` );
return fs . existsSync ( file ) ? JSON . parse ( fs . readFileSync ( file , "utf8" )) : null ;
},
2026-10-23 10:04:13 -07:00
// The app starts detached and the launcher exits at once, so its record can land a moment later.
appArgs : () => {
const file = path . join ( bin , "app.json" );
for ( let waited = 0 ; waited < 10000 && ! fs . existsSync ( file ); waited += 50 ) {
Atomics . wait ( new Int32Array ( new SharedArrayBuffer ( 4 )), 0 , 0 , 50 );
}
return fs . existsSync ( file ) ? JSON . parse ( fs . readFileSync ( file , "utf8" )) : null ;
},
appExists : () => fs . existsSync ( path . join ( bin , "app.json" )),
2026-10-16 19:28:11 -07:00
// A detached release-check refresh may still be writing its cache; retry rather than fail.
2026-10-23 10:04:13 -07:00
// The stand-in app runs detached with the sandbox as its folder, so on Windows it can hold
// the directory for a moment after its record lands, and rmSync's own retries give up on
// that EPERM at once. Try again for a few seconds; a temp folder left behind is harmless.
cleanup : () => {
for ( let attempt = 0 ; attempt < 25 ; attempt ++ ) {
try {
return fs . rmSync ( dir , { recursive : true , force : true , maxRetries : 10 , retryDelay : 100 });
} catch {
Atomics . wait ( new Int32Array ( new SharedArrayBuffer ( 4 )), 0 , 0 , 200 );
}
}
},
2026-09-28 19:37:41 -07:00
};
}
2026-10-16 19:28:11 -07:00
const NOTICE_LINE = /is out \(you have v/ ;
2026-11-15 11:22:58 -08:00
/**
* The run's folder was recorded: first in `recentFolders` (compared by real path, since a temp
* folder can reach the launcher under another spelling), `lastFolder` equal to it, and `older`
* after it in order.
*/
function assertRecordedFirst ({ recentFolders , lastFolder }, folder , older = []) {
assert . ok ( Array . isArray ( recentFolders ), "recentFolders is written" );
assert . equal ( fs . realpathSync ( recentFolders [ 0 ]), fs . realpathSync ( folder ));
assert . equal ( lastFolder , recentFolders [ 0 ]);
assert . deepEqual ( recentFolders . slice ( 1 ), older );
}
2026-10-16 19:28:11 -07:00
/** Write the console's cached release check, `ageMs` old. */
function writeCache ( box , latest , ageMs = 0 ) {
fs . mkdirSync ( path . dirname ( box . cacheFile ), { recursive : true });
fs . writeFileSync ( box . cacheFile , JSON . stringify ({ checkedAt : Date . now () - ageMs , latest }));
}
2026-09-28 19:37:41 -07:00
test ( "launcher: Claude Code gets the prompt first, then bypassPermissions and the forwarded args" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
2026-11-08 13:48:28 -08:00
const result = box . run ([ "--bypass-permissions" , "--verbose" ]);
2026-09-28 19:37:41 -07:00
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "claude" ), [ "/plan2code" , "--permission-mode" , "bypassPermissions" , "--verbose" ]);
assert . match ( result . stdout , new RegExp ( `Claude Code ${ NOTICE } ` ));
});
test ( "launcher: Devin keeps its args ahead of the -- and the prompt" , ( t ) => {
const box = sandbox ([ "devin" ]);
t . after ( box . cleanup );
2026-11-08 13:48:28 -08:00
const result = box . run ([ "--bypass-permissions" , "--verbose" ]);
2026-09-28 19:37:41 -07:00
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "devin" ), [ "--permission-mode" , "bypass" , "--verbose" , "--" , "/plan2code" ]);
});
2026-10-08 16:54:18 -07:00
test ( "launcher: Codex gets the bypass flag, the forwarded args, then the $plan2code prompt" , ( t ) => {
const box = sandbox ([ "codex" ]);
t . after ( box . cleanup );
2026-11-08 13:48:28 -08:00
const result = box . run ([ "--bypass-permissions" , "--verbose" ]);
2026-10-08 16:54:18 -07:00
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "codex" ), [ "--dangerously-bypass-approvals-and-sandbox" , "--verbose" , "$plan2code" ]);
});
2026-10-27 18:20:31 -07:00
test ( "launcher: --keep-permissions keeps every built-in's permission prompts, and is never forwarded" , ( t ) => {
const box = sandbox ([ "claude" , "devin" , "codex" ]);
t . after ( box . cleanup );
const expected = {
claude : [ "/plan2code" , "--verbose" ],
devin : [ "--verbose" , "--" , "/plan2code" ],
codex : [ "--verbose" , "$plan2code" ],
};
for ( const [ cli , args ] of Object . entries ( expected )) {
const result = box . run ([ "--cli" , cli , "--keep-permissions" , "--verbose" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( cli ), args , cli );
}
});
2026-11-08 13:48:28 -08:00
test ( "launcher: with no terminal and no flag every built-in keeps its permission prompts" , ( t ) => {
const box = sandbox ([ "claude" , "devin" , "codex" ]);
t . after ( box . cleanup );
const expected = {
claude : [ "/plan2code" , "--verbose" ],
devin : [ "--verbose" , "--" , "/plan2code" ],
codex : [ "--verbose" , "$plan2code" ],
};
for ( const [ cli , args ] of Object . entries ( expected )) {
const result = box . run ([ "--cli" , cli , "--verbose" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( cli ), args , cli );
assert . doesNotMatch ( result . stdout , /off\?/ , cli );
}
});
test ( "launcher: --bypass-permissions turns every built-in's prompts off with no terminal, and is never forwarded" , ( t ) => {
const box = sandbox ([ "claude" , "devin" , "codex" ]);
t . after ( box . cleanup );
const expected = {
claude : [ "/plan2code" , "--permission-mode" , "bypassPermissions" , "--verbose" ],
devin : [ "--permission-mode" , "bypass" , "--verbose" , "--" , "/plan2code" ],
codex : [ "--dangerously-bypass-approvals-and-sandbox" , "--verbose" , "$plan2code" ],
};
for ( const [ cli , args ] of Object . entries ( expected )) {
const result = box . run ([ "--cli" , cli , "--bypass-permissions" , "--verbose" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( cli ), args , cli );
}
// --keep-permissions wins when both are given.
assert . equal ( box . run ([ "--cli" , "claude" , "--bypass-permissions" , "--keep-permissions" ]). status , 0 );
assert . deepEqual ( box . argsOf ( "claude" ), [ "/plan2code" ]);
});
test ( "launcher: the keyboard question names what the flag drops, and Codex's names its sandbox" , () => {
const { bypassQuestion } = require ( LAUNCHER );
const claude = bypassQuestion ({ id : "claude" , label : "Claude Code" , bypassArgs : [ "--permission-mode" , "bypassPermissions" ] });
assert . equal ( claude . heading , "Turn Claude Code's permission prompts off?" );
assert . equal ( claude . prompt , "Turn permission prompts off?" );
assert . match ( claude . detail , /without asking \(--permission-mode bypassPermissions\)/ );
assert . doesNotMatch ( claude . detail , /sandbox/ );
assert . equal ( claude . hint , "Type n to keep the permission prompts, or press Enter to turn them off." );
const codex = bypassQuestion ({ id : "codex" , label : "Codex" , bypassArgs : [ "--dangerously-bypass-approvals-and-sandbox" ] });
assert . equal ( codex . heading , "Turn Codex's approval prompts and its sandbox off?" );
assert . equal ( codex . prompt , "Turn approval prompts and its sandbox off?" );
assert . match ( codex . detail , /outside its sandbox \(--dangerously-bypass-approvals-and-sandbox\)/ );
assert . equal ( codex . hint , "Type n to keep the approval prompts and its sandbox, or press Enter to turn them off." );
// A custom agent gets the plain wording, with its own arguments.
const goose = bypassQuestion ({ id : "goose" , label : "Goose" , bypassArgs : [ "--bypass" ] });
assert . equal ( goose . heading , "Turn Goose's permission prompts off?" );
assert . match ( goose . detail , /\(--bypass\)/ );
});
2026-10-08 16:54:18 -07:00
test ( "launcher: --cli codex picks Codex when it is installed beside another CLI" , ( t ) => {
const box = sandbox ([ "claude" , "codex" ]);
t . after ( box . cleanup );
const result = box . run ([ "--cli" , "codex" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . equal ( box . argsOf ( "claude" ), null );
assert . ok ( box . argsOf ( "codex" ));
});
test ( "launcher: the shipped models.json lists every CLI, and every entry has an id and a label" , () => {
const shipped = JSON . parse ( fs . readFileSync ( path . join ( path . dirname ( LAUNCHER ), "models.json" ), "utf8" ));
2026-10-11 16:39:25 -07:00
for ( const cli of [ "claude" , "devin" , "codex" ]) {
assert . ok ( Array . isArray ( shipped [ cli ]), cli );
for ( const { id , label } of shipped [ cli ]) assert . ok ( id && label , cli );
}
});
test ( "launcher: Codex takes a forwarded --model ahead of the $plan2code prompt, with no notice" , ( t ) => {
const box = sandbox ([ "codex" ]);
t . after ( box . cleanup );
const result = box . run ([ "--cli" , "codex" , "--model" , "x" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . doesNotMatch ( result . stdout , new RegExp ( NOTICE ));
2026-11-08 13:48:28 -08:00
assert . deepEqual ( box . argsOf ( "codex" ), [ "--model" , "x" , "$plan2code" ]);
2026-10-11 16:39:25 -07:00
});
test ( "launcher: Codex's -m counts as a model already chosen" , ( t ) => {
const box = sandbox ([ "codex" ]);
t . after ( box . cleanup );
const result = box . run ([ "--cli" , "codex" , "-m" , "x" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . doesNotMatch ( result . stdout , new RegExp ( NOTICE ));
2026-11-08 13:48:28 -08:00
assert . deepEqual ( box . argsOf ( "codex" ), [ "-m" , "x" , "$plan2code" ]);
2026-10-11 16:39:25 -07:00
});
test ( "launcher: hasModelFlag reads -m as a model only for Codex" , () => {
const { hasModelFlag } = require ( LAUNCHER );
for ( const cli of [ "claude" , "devin" , "codex" ]) {
assert . equal ( hasModelFlag ([ "--model" , "x" ], cli ), true , cli );
assert . equal ( hasModelFlag ([ "--model=x" ], cli ), true , cli );
assert . equal ( hasModelFlag ([ "--verbose" ], cli ), false , cli );
}
for ( const args of [[ "-m" , "x" ], [ "-m=x" ], [ "-mx" ]]) {
assert . equal ( hasModelFlag ( args , "codex" ), true , args . join ( " " ));
assert . equal ( hasModelFlag ( args , "claude" ), false , args . join ( " " ));
}
});
test ( "launcher: without a terminal, Codex prints the model notice" , ( t ) => {
const box = sandbox ([ "codex" ]);
t . after ( box . cleanup );
const result = box . run ([]);
assert . equal ( result . status , 0 , result . stderr );
assert . match ( result . stdout , new RegExp ( `Codex ${ NOTICE } ` ));
assert . match ( result . stdout , /`codex` on its own/ );
2026-10-08 16:54:18 -07:00
});
2026-09-28 19:37:41 -07:00
test ( "launcher: a forwarded --model skips the model notice" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
for ( const args of [[ "--model" , "opus" ], [ "--model=opus" ]]) {
const result = box . run ( args );
assert . equal ( result . status , 0 , result . stderr );
assert . doesNotMatch ( result . stdout , new RegExp ( NOTICE ));
2026-11-08 13:48:28 -08:00
assert . deepEqual ( box . argsOf ( "claude" ), [ "/plan2code" , ... args ]);
2026-09-28 19:37:41 -07:00
}
});
2026-11-03 03:21:20 -08:00
test ( "launcher: a launched model is remembered per agent in launcher.json" , ( t ) => {
const box = sandbox ([ "claude" , "codex" ]);
t . after ( box . cleanup );
fs . mkdirSync ( path . dirname ( box . stateFile ), { recursive : true });
fs . writeFileSync ( box . stateFile , JSON . stringify ({ lastFolder : box . home }));
assert . equal ( box . run ([ "--cli" , "claude" , "--model" , "opus" ]). status , 0 );
assert . equal ( box . run ([ "--cli" , "codex" , "-m" , "x" ]). status , 0 );
assert . equal ( box . run ([ "--cli" , "codex" , "-my" ]). status , 0 );
2026-11-15 11:22:58 -08:00
const { recentFolders , lastFolder , ... rest } = JSON . parse ( fs . readFileSync ( box . stateFile , "utf8" ));
assert . deepEqual ( rest , { lastCli : "codex" , lastModels : { claude : "opus" , codex : "y" } });
assertRecordedFirst ({ recentFolders , lastFolder }, box . dir , [ box . home ]);
2026-11-03 03:21:20 -08:00
});
2026-09-28 19:37:41 -07:00
test ( "launcher: --cli picks the CLI and is never forwarded; the pick is merged into launcher.json" , ( t ) => {
const box = sandbox ([ "claude" , "devin" ]);
t . after ( box . cleanup );
fs . mkdirSync ( path . dirname ( box . stateFile ), { recursive : true });
fs . writeFileSync ( box . stateFile , JSON . stringify ({ lastFolder : box . home }));
for ( const args of [[ "--cli" , "devin" ], [ "--cli=DEVIN" ]]) {
const result = box . run ( args );
assert . equal ( result . status , 0 , result . stderr );
2026-11-08 13:48:28 -08:00
assert . deepEqual ( box . argsOf ( "devin" ), [ "--" , "/plan2code" ]);
2026-09-28 19:37:41 -07:00
}
assert . equal ( box . argsOf ( "claude" ), null );
2026-11-15 11:22:58 -08:00
const { recentFolders , lastFolder , ... rest } = JSON . parse ( fs . readFileSync ( box . stateFile , "utf8" ));
assert . deepEqual ( rest , { lastCli : "devin" });
assertRecordedFirst ({ recentFolders , lastFolder }, box . dir , [ box . home ]);
2026-09-28 19:37:41 -07:00
});
test ( "launcher: with both installed and no terminal to ask in, the last pick wins" , ( t ) => {
const box = sandbox ([ "claude" , "devin" ]);
t . after ( box . cleanup );
fs . mkdirSync ( path . dirname ( box . stateFile ), { recursive : true });
fs . writeFileSync ( box . stateFile , JSON . stringify ({ lastCli : "devin" }));
assert . equal ( box . run ([]). status , 0 );
assert . notEqual ( box . argsOf ( "devin" ), null );
assert . equal ( box . argsOf ( "claude" ), null );
});
2026-10-11 16:39:25 -07:00
test ( "launcher: with all three installed and no terminal, a last pick of codex opens Codex" , ( t ) => {
const box = sandbox ([ "claude" , "devin" , "codex" ]);
t . after ( box . cleanup );
fs . mkdirSync ( path . dirname ( box . stateFile ), { recursive : true });
fs . writeFileSync ( box . stateFile , JSON . stringify ({ lastCli : "codex" }));
assert . equal ( box . run ([]). status , 0 );
assert . notEqual ( box . argsOf ( "codex" ), null );
assert . equal ( box . argsOf ( "claude" ), null );
assert . equal ( box . argsOf ( "devin" ), null );
});
2026-09-28 19:37:41 -07:00
test ( "launcher: an unknown --cli exits 2, a missing CLI 127, and nothing is started" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const unknown = box . run ([ "--cli" , "bogus" ]);
assert . equal ( unknown . status , 2 );
2026-10-11 16:39:25 -07:00
assert . match ( unknown . stderr , /--cli takes claude, devin or codex, not "bogus"/ );
2026-09-28 19:37:41 -07:00
const missing = box . run ([ "--cli" , "devin" ]);
assert . equal ( missing . status , 127 );
assert . match ( missing . stderr , /the `devin` CLI was not found/ );
2026-10-11 16:39:25 -07:00
assert . match ( missing . stderr , /\n\nTo use Devin:\n/ );
2026-11-03 03:21:20 -08:00
assert . ok ( missing . stderr . includes ( "1. Install it: https://devin.ai (https://docs.devin.ai/work-with-devin/devin-cli)" ));
2026-10-11 16:39:25 -07:00
assert . ok ( missing . stderr . includes ( "start Devin and type /plan2code." ));
// Only the steps for the requested CLI: no "install one of" list that contradicts it.
assert . doesNotMatch ( missing . stderr , /Install one:/ );
const missingCodex = box . run ([ "--cli" , "codex" ]);
assert . equal ( missingCodex . status , 127 );
assert . ok ( missingCodex . stderr . includes ( "npm i -g @openai/codex" ));
assert . ok ( missingCodex . stderr . includes ( "type $plan2code." ));
2026-09-28 19:37:41 -07:00
assert . equal ( box . argsOf ( "claude" ), null );
});
2026-10-02 20:51:34 -07:00
test ( "launcher: mergeModels keeps the shipped list first and drops user duplicates" , () => {
const { mergeModels , modelEntries } = require ( LAUNCHER );
const shipped = [{ id : "a" , label : "A" }, { id : "b" , label : "B" }];
const user = [{ id : "b" , label : "B old" }, { id : "c" , label : "C" }, { id : "c" , label : "C again" }];
assert . deepEqual ( mergeModels ( shipped , user ), [... shipped , { id : "c" , label : "C" }]);
assert . deepEqual ( mergeModels ( shipped , []), shipped );
// A missing or corrupt user file yields no additions rather than an error.
assert . deepEqual ( modelEntries ( null , "devin" ), []);
assert . deepEqual ( modelEntries ({ devin : "nope" }, "devin" ), []);
assert . deepEqual ( modelEntries ({ devin : [{ id : 1 }, null , { id : "ok" , label : "Ok" }] }, "devin" ), [{ id : "ok" , label : "Ok" }]);
});
2026-11-04 19:23:52 -08:00
test ( "launcher: a strengths key in the models files is never read as a model list, and every shipped strength names a listed model" , () => {
const { modelEntries , mergeModels } = require ( LAUNCHER );
const shipped = JSON . parse ( fs . readFileSync ( path . join ( path . dirname ( LAUNCHER ), "models.json" ), "utf8" ));
assert . ok ( shipped . strengths && typeof shipped . strengths === "object" );
assert . deepEqual ( modelEntries ( shipped , "strengths" ), []);
const claude = modelEntries ( shipped , "claude" );
assert . ok ( claude . length > 0 );
const user = { claude : [{ id : "mine" , label : "Mine" }], strengths : { claude : { best : { model : "mine" } } } };
assert . deepEqual ( modelEntries ( user , "strengths" ), []);
assert . deepEqual ( mergeModels ( claude , modelEntries ( user , "claude" )), [... claude , { id : "mine" , label : "Mine" }]);
assert . deepEqual ( mergeModels ( claude , modelEntries ({ claude : user . claude }, "claude" )), mergeModels ( claude , modelEntries ( user , "claude" )));
// Only Claude Code and Devin ship a mapping, and every row names a model in that agent's list.
assert . deepEqual ( Object . keys ( shipped . strengths ). sort (), [ "claude" , "devin" ]);
for ( const [ agent , rows ] of Object . entries ( shipped . strengths )) {
assert . deepEqual ( Object . keys ( rows ), [ "thrifty" , "balanced" , "best" ], agent );
const ids = new Set ( shipped [ agent ]. map (( m ) => m . id ));
for ( const row of Object . values ( rows )) assert . ok ( ids . has ( row . model ), ` ${ agent } : ${ row . model } ` );
}
});
2026-10-02 20:51:34 -07:00
test ( "launcher: the shipped models.json is curated Devin at low/medium/high only" , () => {
const shipped = JSON . parse ( fs . readFileSync ( path . join ( path . dirname ( LAUNCHER ), "models.json" ), "utf8" ));
assert . ok ( shipped . claude . length > 0 );
assert . ok ( shipped . devin . length > 0 && shipped . devin . length <= 30 );
for ( const { id , label } of shipped . devin ) {
assert . ok ( id && label );
assert . doesNotMatch ( id , /(xhigh|max|fast|priority)$/ );
}
});
2026-10-25 21:26:08 -07:00
test ( "launcher: with no CLI installed it exits 127 and explains how to get one and how to run the skill from an agent" , ( t ) => {
2026-09-28 19:37:41 -07:00
const box = sandbox ([]);
t . after ( box . cleanup );
const result = box . run ([]);
assert . equal ( result . status , 127 );
2026-10-25 21:26:08 -07:00
assert . match ( result . stderr , /Plan2Code runs inside an AI coding agent CLI, and none was found/ );
// Every built-in's label, install command and official page.
for ( const part of [
"Claude Code: npm i -g @anthropic-ai/claude-code" ,
"https://code.claude.com/docs/en/setup" ,
"Codex: npm i -g @openai/codex" ,
"https://github.com/openai/codex" ,
"Devin: https://devin.ai" ,
"https://docs.devin.ai/work-with-devin/devin-cli" ,
]) {
assert . ok ( result . stderr . includes ( part ), part );
}
2026-11-03 03:21:20 -08:00
assert . ok ( result . stderr . includes ( "Add it by editing `~/.plan2code/agents.json`, then run `plan2code` again." ));
assert . doesNotMatch ( result . stderr , /User Preferences/ );
2026-10-25 21:26:08 -07:00
assert . ok ( result . stderr . includes ( "type /plan2code ($plan2code in Codex)" ));
2026-10-08 16:54:18 -07:00
assert . match ( result . stderr , /cd into the project/ );
2026-09-28 19:37:41 -07:00
});
test ( "launcher: a forwarded argument with a space and a cmd metacharacter arrives unchanged" , ( t ) => {
// On Windows the stand-in is a .cmd, so this goes through the cmd.exe quoting in quoteForCmd.
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const result = box . run ([ "--append-system-prompt" , "a b&c" ]);
assert . equal ( result . status , 0 , result . stderr );
2026-11-08 13:48:28 -08:00
assert . deepEqual ( box . argsOf ( "claude" ), [ "/plan2code" , "--append-system-prompt" , "a b&c" ]);
2026-09-28 19:37:41 -07:00
});
test ( "launcher: the CLI's non-zero exit code is passed through" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const result = box . run ([], { P2C_TEST_EXIT : "7" });
assert . equal ( result . status , 7 , result . stderr );
assert . notEqual ( box . argsOf ( "claude" ), null );
});
2026-10-16 19:28:11 -07:00
test ( "launcher: update runs the npx install and starts no agent" , ( t ) => {
const box = sandbox ([ "npx" , "claude" ]);
t . after ( box . cleanup );
const result = box . run ([ "update" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . match ( result . stdout , /Updating Plan2Code\.\.\./ );
const args = box . argsOf ( "npx" );
assert . ok ( args , "npx was not run" );
assert . ok ( args . includes ( "--update" ), args . join ( " " ));
assert . ok ( args . includes ( "git+https://github.com/jparkerweb/plan2code.git" ), args . join ( " " ));
assert . equal ( box . argsOf ( "claude" ), null );
});
test ( "launcher: update passes npx's exit code through" , ( t ) => {
const box = sandbox ([ "npx" ]);
t . after ( box . cleanup );
assert . equal ( box . run ([ "update" ], { P2C_TEST_EXIT : "3" }). status , 3 );
});
2026-11-08 17:25:40 -08:00
test ( "launcher: uninstall runs the npx install with --uninstall and starts no agent" , ( t ) => {
const box = sandbox ([ "npx" , "claude" ]);
t . after ( box . cleanup );
const result = box . run ([ "uninstall" , "--yes" , "--purge" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . match ( result . stdout , /Uninstalling Plan2Code\.\.\./ );
const args = box . argsOf ( "npx" );
assert . ok ( args , "npx was not run" );
assert . ok ( args . includes ( "--uninstall" ) && args . includes ( "--yes" ) && args . includes ( "--purge" ), args . join ( " " ));
assert . ok ( ! args . includes ( "--update" ), args . join ( " " ));
assert . equal ( box . argsOf ( "claude" ), null );
});
test ( "launcher: uninstall passes npx's exit code through" , ( t ) => {
const box = sandbox ([ "npx" ]);
t . after ( box . cleanup );
assert . equal ( box . run ([ "uninstall" ], { P2C_TEST_EXIT : "4" }). status , 4 );
});
test ( "launcher: uninstall refuses an unknown option without running npx" , ( t ) => {
const box = sandbox ([ "npx" ]);
t . after ( box . cleanup );
const result = box . run ([ "uninstall" , "--nuke" ]);
assert . equal ( result . status , 2 );
assert . match ( result . stderr , /unknown option\(s\) for uninstall: --nuke/ );
assert . equal ( box . argsOf ( "npx" ), null );
});
2026-10-16 19:28:11 -07:00
test ( "launcher: release notice prints from a fresh cache" , ( t ) => {
const box = sandbox ([ "claude" ], { installed : "1.0.0" });
t . after ( box . cleanup );
writeCache ( box , "9.9.9" );
const result = box . run ([]);
assert . equal ( result . status , 0 , result . stderr );
assert . ok ( result . stdout . includes ( "Plan2Code v9.9.9 is out (you have v1.0.0). Run: plan2code update" ), result . stdout );
assert . notEqual ( box . argsOf ( "claude" ), null );
});
test ( "launcher: no notice when current, stale or missing, and the start does not wait" , ( t ) => {
// PATH holds only the stand-ins, so the detached refresh finds no git: nothing may wait on it.
const cases = [
[ "current" , ( box ) => writeCache ( box , "1.0.0" )],
[ "stale" , ( box ) => writeCache ( box , "9.9.9" , 2 * 60 * 60 * 1000 )],
[ "missing" , () => {}],
];
for ( const [ name , setup ] of cases ) {
const box = sandbox ([ "claude" ], { installed : "1.0.0" });
t . after ( box . cleanup );
setup ( box );
const started = Date . now ();
const result = box . run ([]);
const took = Date . now () - started ;
assert . equal ( result . status , 0 , ` ${ name } : ${ result . stderr } ` );
assert . doesNotMatch ( result . stdout , NOTICE_LINE , name );
assert . notEqual ( box . argsOf ( "claude" ), null , name );
assert . ok ( took < 5000 , ` ${ name } : the start took ${ took } ms` );
}
});
test ( "launcher: compareVersions orders X.Y.Z numerically and refuses anything else" , () => {
const { compareVersions } = require ( LAUNCHER );
assert . equal ( compareVersions ( "1.9.0" , "1.10.0" ), - 1 );
assert . equal ( compareVersions ( "2.0.0" , "2.0.0" ), 0 );
assert . equal ( compareVersions ( "3.0.0" , "2.9.9" ), 1 );
assert . equal ( compareVersions ( "1.0.0" , null ), null );
assert . equal ( compareVersions ( "v1.0.0" , "1.0.0" ), null );
});
2026-10-27 21:48:43 -07:00
test ( "launcher: parseRegQueryValue reads REG_SZ and REG_EXPAND_SZ, and expandPercentVars fills in names" , () => {
const { parseRegQueryValue , expandPercentVars } = require ( LAUNCHER );
const out = "\r\nHKEY_CURRENT_USER\\Environment\r\n Path REG_EXPAND_SZ %USERPROFILE%\\.pi\\agent\\bin;C:\\Tools\r\n\r\n" ;
assert . equal ( parseRegQueryValue ( out ), "%USERPROFILE%\\.pi\\agent\\bin;C:\\Tools" );
assert . equal ( parseRegQueryValue ( " Path REG_SZ C:\\A\r\n" ), "C:\\A" );
assert . equal ( parseRegQueryValue ( "ERROR: The system was unable to find the specified registry key or value.\r\n" ), null );
assert . equal ( expandPercentVars ( "%userprofile%\\x;%NOPE%\\y" , { USERPROFILE : "C:\\Users\\me" }), "C:\\Users\\me\\x;%NOPE%\\y" );
});
// A terminal opened before an agent's installer added its folder keeps the old PATH: the
// launcher reads the saved one too, so a custom agent is offered in every terminal.
test ( "launcher: on Windows the saved user PATH fills in folders the inherited PATH lacks" , { skip : ! IS_WINDOWS }, ( t ) => {
const { addSavedWindowsPath , parseRegQueryValue , expandPercentVars } = require ( LAUNCHER );
const reg = spawnSync ( path . join ( process . env . SystemRoot , "System32" , "reg.exe" ), [ "query" , "HKCU\\Environment" , "/v" , "Path" ], { encoding : "utf8" });
const saved = parseRegQueryValue ( reg . stdout );
if ( ! saved ) return t . skip ( "no user PATH saved in the registry" );
const first = expandPercentVars ( saved ). split ( ";" ). find ( Boolean );
const pathKey = Object . keys ( process . env ). find (( key ) => key . toUpperCase () === "PATH" );
const before = { PATH : process . env [ pathKey ], NO : process . env . PLAN2CODE_NO_SAVED_PATH };
t . after (() => {
process . env [ pathKey ] = before . PATH ;
if ( before . NO === undefined ) delete process . env . PLAN2CODE_NO_SAVED_PATH ;
else process . env . PLAN2CODE_NO_SAVED_PATH = before . NO ;
});
delete process . env . PLAN2CODE_NO_SAVED_PATH ;
process . env [ pathKey ] = "C:\\stale-terminal-path" ;
addSavedWindowsPath ();
const dirs = process . env [ pathKey ]. split ( ";" );
assert . equal ( dirs [ 0 ], "C:\\stale-terminal-path" , "the inherited PATH keeps its place in front" );
assert . ok ( dirs . includes ( first ), ` ${ first } is added from the saved PATH` );
const length = dirs . length ;
addSavedWindowsPath ();
assert . equal ( process . env [ pathKey ]. split ( ";" ). length , length , "a second call adds nothing twice" );
});
Sync upstream web console updates into v2.4.2: on-demand Cleanup of unused ~/.plan2code files, an UPDATE AVAILABLE banner from the release tags, a colored launcher with a Planny banner, Notes threads that keep the person's notes and read older reply shapes, the repo-local plan2code-model-update maintainer skill, and review fixes (413 for oversize bodies, notes kept on skip, scoped reconnect banner, live Overview tab, busy state on 409, menu keyboard focus, case-insensitive mentions)
2026-10-05 19:10:45 -07:00
test ( "launcher: renderBanner draws Planny and the name, colored only through paint" , () => {
const { renderBanner , paint } = require ( LAUNCHER );
const plain = renderBanner ( paint ( false ));
assert . doesNotMatch ( plain , /\x1b/ );
for ( const part of [ "╭───╮" , "╰┬─┬╯" , "★" , "Plan2Code" ]) assert . ok ( plain . includes ( part ), part );
assert . ok ( plain . split ( "\n" ). length >= 4 );
const colored = renderBanner ( paint ( true ));
assert . ok ( colored . includes ( "\x1b[" ));
assert . ok ( colored . includes ( "\x1b[0m" ));
});
test ( "launcher: paint wraps text in the escape codes only when color is on" , () => {
const { paint } = require ( LAUNCHER );
assert . equal ( paint ( false ). red ( "x" ), "x" );
assert . equal ( paint ( true ). red ( "x" ), "\x1b[31mx\x1b[0m" );
});
test ( "launcher: a piped run prints no escape codes, with or without NO_COLOR" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const none = sandbox ([]);
t . after ( none . cleanup );
for ( const env of [{}, { NO_COLOR : "1" }]) {
const runs = [ box . run ([], env ), box . run ([ "--cli" , "bogus" ], env ), none . run ([], env )];
assert . deepEqual ( runs . map (( r ) => r . status ), [ 0 , 2 , 127 ]);
for ( const r of runs ) {
assert . doesNotMatch ( r . stdout , /\x1b/ );
assert . doesNotMatch ( r . stderr , /\x1b/ );
}
}
});
2026-10-23 10:04:13 -07:00
// The desktop app hand-off. The stand-in app is found through PLAN2CODE_APP; "no display" is
// only something a Linux run can ask for, since Windows and macOS always count as having one.
const NO_DISPLAY = { DISPLAY : "" , WAYLAND_DISPLAY : "" };
2026-11-08 13:48:28 -08:00
const CLASSIC_ARGS = [ "/plan2code" ];
2026-10-23 10:04:13 -07:00
test ( "launcher app: with no app installed the agent starts exactly as before" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const result = box . run ([]);
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "claude" ), CLASSIC_ARGS );
assert . equal ( box . appExists (), false );
});
test ( "launcher app: --classic runs today's flow even with the app installed, and is never forwarded" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const result = box . run ([ "--classic" , "--verbose" ], { PLAN2CODE_APP : box . appFile });
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "claude" ), [... CLASSIC_ARGS , "--verbose" ]);
assert . equal ( box . appExists (), false );
});
test ( "launcher app: no display on Linux runs today's flow even with the app installed" , { skip : process . platform !== "linux" }, ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const result = box . run ([], { PLAN2CODE_APP : box . appFile , ... NO_DISPLAY });
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "claude" ), CLASSIC_ARGS );
assert . equal ( box . appExists (), false );
});
test ( "launcher app: with the app and a display it starts the app on the folder, agent and model, and no agent" , ( t ) => {
const box = sandbox ([ "claude" , "codex" ]);
t . after ( box . cleanup );
const display = process . platform === "linux" ? { DISPLAY : ":0" } : {};
const result = box . run ([ "--cli" , "codex" , "--model" , "gpt-5" ], { PLAN2CODE_APP : box . appFile , ... display });
assert . equal ( result . status , 0 , result . stderr );
const appArgs = box . appArgs ();
assert . ok ( appArgs , "the stand-in app was never started" );
// The launcher runs in the sandbox folder, so that folder is the project.
assert . equal ( appArgs [ 0 ], "--project" );
assert . equal ( fs . realpathSync ( appArgs [ 1 ]), fs . realpathSync ( box . dir ));
assert . deepEqual ( appArgs . slice ( 2 ), [ "--agent" , "codex" , "--model" , "gpt-5" ]);
assert . equal ( box . argsOf ( "claude" ), null );
assert . equal ( box . argsOf ( "codex" ), null );
assert . match ( result . stdout , /Opened the Plan2Code app/ );
});
test ( "launcher app: a model is left out of the app's arguments when none was chosen" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const display = process . platform === "linux" ? { DISPLAY : ":0" } : {};
const result = box . run ([], { PLAN2CODE_APP : box . appFile , ... display });
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . appArgs (). slice ( 2 ), [ "--agent" , "claude" ]);
});
test ( "launcher app: an app that cannot start falls back to the terminal flow" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const display = process . platform === "linux" ? { DISPLAY : ":0" } : {};
// Present but not runnable (no execute bit on POSIX, not a program on Windows).
const broken = path . join ( path . dirname ( box . appFile ), IS_WINDOWS ? "broken.exe" : "broken" );
fs . writeFileSync ( broken , "not a program" );
const result = box . run ([], { PLAN2CODE_APP : broken , ... display });
assert . equal ( result . status , 0 , result . stderr );
assert . match ( result . stderr , /could not start the app/ );
assert . deepEqual ( box . argsOf ( "claude" ), CLASSIC_ARGS );
});
test ( "launcher app: modelFrom reads --model, --model= and Codex's -m" , () => {
const { modelFrom } = require ( LAUNCHER );
assert . equal ( modelFrom ([ "--model" , "x" ], "claude" ), "x" );
assert . equal ( modelFrom ([ "--model=x" ], "claude" ), "x" );
assert . equal ( modelFrom ([ "-m" , "x" ], "codex" ), "x" );
assert . equal ( modelFrom ([ "-m=x" ], "codex" ), "x" );
2026-11-03 03:21:20 -08:00
assert . equal ( modelFrom ([ "-mx" ], "codex" ), "x" );
assert . equal ( modelFrom ([ "-m" ], "codex" ), null );
2026-10-23 10:04:13 -07:00
assert . equal ( modelFrom ([ "-m" , "x" ], "claude" ), null );
assert . equal ( modelFrom ([ "--verbose" ], "claude" ), null );
});
test ( "launcher app: an app that starts and then exits with a failure falls back to the terminal flow" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const display = process . platform === "linux" ? { DISPLAY : ":0" } : {};
const result = box . run ([], { PLAN2CODE_APP : box . crashFile , ... display });
assert . equal ( result . status , 0 , result . stderr );
assert . match ( result . stderr , /the app exited at once \(code 3\)/ );
assert . deepEqual ( box . argsOf ( "claude" ), CLASSIC_ARGS );
assert . doesNotMatch ( result . stdout , /Opened the Plan2Code app/ );
});
test ( "launcher app: hasDisplay refuses an SSH session on Windows and macOS, but Linux only cares about DISPLAY" , () => {
const launcherPath = require . resolve ( LAUNCHER );
const realPlatform = process . platform ;
const saved = {
DISPLAY : process . env . DISPLAY ,
WAYLAND_DISPLAY : process . env . WAYLAND_DISPLAY ,
SSH_CONNECTION : process . env . SSH_CONNECTION ,
SSH_TTY : process . env . SSH_TTY ,
};
for ( const key of Object . keys ( saved )) delete process . env [ key ];
// IS_WINDOWS/IS_MAC are consts captured from process.platform at require time, so testing a
// platform other than this machine's needs a fresh module instance loaded under a faked one.
function hasDisplayOn ( platform ) {
Object . defineProperty ( process , "platform" , { value : platform , configurable : true });
delete require . cache [ launcherPath ];
try {
return require ( LAUNCHER ). hasDisplay ();
} finally {
Object . defineProperty ( process , "platform" , { value : realPlatform , configurable : true });
delete require . cache [ launcherPath ];
}
}
try {
for ( const platform of [ "win32" , "darwin" ]) {
assert . equal ( hasDisplayOn ( platform ), true , platform );
process . env . SSH_CONNECTION = "10.0.0.1 51000 10.0.0.2 22" ;
assert . equal ( hasDisplayOn ( platform ), false , ` ${ platform } SSH_CONNECTION` );
delete process . env . SSH_CONNECTION ;
process . env . SSH_TTY = "/dev/ttys000" ;
assert . equal ( hasDisplayOn ( platform ), false , ` ${ platform } SSH_TTY` );
delete process . env . SSH_TTY ;
}
// Linux never looks at the SSH env vars; DISPLAY/WAYLAND_DISPLAY alone still decides.
process . env . SSH_CONNECTION = "10.0.0.1 51000 10.0.0.2 22" ;
assert . equal ( hasDisplayOn ( "linux" ), false );
process . env . DISPLAY = ":0" ;
assert . equal ( hasDisplayOn ( "linux" ), true );
delete process . env . DISPLAY ;
delete process . env . SSH_CONNECTION ;
} finally {
for ( const [ key , value ] of Object . entries ( saved )) {
if ( value === undefined ) delete process . env [ key ];
else process . env [ key ] = value ;
}
// Re-require with the real platform so later tests in this file see the host's own module.
delete require . cache [ launcherPath ];
require ( LAUNCHER );
}
});
test ( "launcher app: looksLikeProject checks for a .git entry, AGENTS.md or a specs folder" , () => {
const { looksLikeProject } = require ( LAUNCHER );
const dir = fs . mkdtempSync ( path . join ( os . tmpdir (), "p2c-project-" ));
try {
assert . equal ( looksLikeProject ( dir ), false );
fs . writeFileSync ( path . join ( dir , "AGENTS.md" ), "" );
assert . equal ( looksLikeProject ( dir ), true );
fs . rmSync ( path . join ( dir , "AGENTS.md" ));
// A worktree's .git is a file, not a directory, and still counts.
fs . writeFileSync ( path . join ( dir , ".git" ), "gitdir: ../elsewhere/.git/worktrees/x\n" );
assert . equal ( looksLikeProject ( dir ), true );
fs . rmSync ( path . join ( dir , ".git" ));
assert . equal ( looksLikeProject ( dir ), false );
fs . mkdirSync ( path . join ( dir , "specs" ));
assert . equal ( looksLikeProject ( dir ), true );
} finally {
fs . rmSync ( dir , { recursive : true , force : true });
}
});
test ( "launcher app: a folder that doesn't look like a project is refused without a terminal to confirm it" , ( t ) => {
const box = sandbox ([ "claude" ], { project : false });
t . after ( box . cleanup );
const result = box . run ([]);
assert . equal ( result . status , 0 , result . stderr );
assert . match ( result . stderr , /doesn't look like a project/ );
assert . equal ( box . argsOf ( "claude" ), null );
});
test ( "launcher app: an AGENTS.md marks the folder as a project, so the agent starts as usual" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const result = box . run ([]);
assert . equal ( result . status , 0 , result . stderr );
assert . doesNotMatch ( result . stderr , /doesn't look like a project/ );
assert . notEqual ( box . argsOf ( "claude" ), null );
});
2026-10-25 21:26:08 -07:00
// Custom agents (~/.plan2code/agents.json). The shared fixture is the contract the console and
// the desktop app read too; the rest starts real stand-ins from a temp home.
const CASES = JSON . parse ( fs . readFileSync ( path . join ( ROOT , "scripts" , "fixtures" , "agents-cases.json" ), "utf8" ));
const GOOSE = {
id : "goose" ,
name : "Goose" ,
command : "goose" ,
args : [ "--yes" , "{prompt}" ],
bypassArgs : [ "--bypass" ],
models : [{ id : "m1" , label : "Model one" }, { id : "m2" }],
};
/** Write ~/.plan2code/agents.json (an object is stringified; a string goes in as it is). */
function writeAgents ( box , file ) {
const target = path . join ( box . home , ".plan2code" , "agents.json" );
fs . mkdirSync ( path . dirname ( target ), { recursive : true });
fs . writeFileSync ( target , typeof file === "string" ? file : JSON . stringify ( file ));
return target ;
}
const goose = ( extra = {}) => ({ schema : 1 , agents : [{ ... GOOSE , ... extra }] });
for ( const c of CASES . files ) {
test ( `launcher agents file: ${ c . name } ` , () => {
const { normalizeAgents } = require ( LAUNCHER );
const { agents , warnings } = normalizeAgents ( c . raw );
assert . deepEqual ( agents , c . agents );
if ( ! c . warnings . length ) assert . deepEqual ( warnings , []);
for ( const part of c . warnings ) {
assert . ok ( warnings . some (( w ) => w . includes ( part )), `a warning names " ${ part } ": ${ JSON . stringify ( warnings ) } ` );
}
});
}
for ( const c of CASES . buildArgs ) {
test ( `launcher buildArgs: ${ c . name } ` , () => {
const { buildArgs } = require ( LAUNCHER );
assert . deepEqual ( buildArgs ( c . entry , c . options ), c . args );
});
}
test ( "launcher agents: --cli <custom id> starts it with args, the model through modelArgs, then bypassArgs and the forwarded args" , ( t ) => {
const box = sandbox ([ "claude" , "goose" ]);
t . after ( box . cleanup );
writeAgents ( box , goose ());
2026-11-08 13:48:28 -08:00
const result = box . run ([ "--cli" , "goose" , "--bypass-permissions" , "--model" , "m1" , "--verbose" ]);
2026-10-25 21:26:08 -07:00
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "goose" ), [ "--yes" , "/plan2code" , "--model" , "m1" , "--bypass" , "--verbose" ]);
assert . equal ( box . argsOf ( "claude" ), null );
assert . equal ( JSON . parse ( fs . readFileSync ( box . stateFile , "utf8" )). lastCli , "goose" );
// No model chosen and no models flag: the model arguments are left out.
2026-11-08 13:48:28 -08:00
assert . equal ( box . run ([ "--cli=goose" , "--bypass-permissions" ]). status , 0 );
2026-10-25 21:26:08 -07:00
assert . deepEqual ( box . argsOf ( "goose" ), [ "--yes" , "/plan2code" , "--bypass" ]);
2026-10-27 18:20:31 -07:00
// --keep-permissions leaves bypassArgs out.
assert . equal ( box . run ([ "--cli=goose" , "--keep-permissions" ]). status , 0 );
assert . deepEqual ( box . argsOf ( "goose" ), [ "--yes" , "/plan2code" ]);
});
test ( "launcher agents: a custom agent with no bypassArgs is never asked about prompts and starts with its own" , ( t ) => {
const box = sandbox ([ "goose" ]);
t . after ( box . cleanup );
writeAgents ( box , goose ({ bypassArgs : [] }));
const result = box . run ([ "--cli" , "goose" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "goose" ), [ "--yes" , "/plan2code" ]);
assert . doesNotMatch ( result . stdout , /permission prompts off/ );
2026-10-25 21:26:08 -07:00
});
test ( "launcher agents: the last pick can be a custom id, and the --cli error names custom ids" , ( t ) => {
const box = sandbox ([ "claude" , "goose" ]);
t . after ( box . cleanup );
writeAgents ( box , goose ());
fs . mkdirSync ( path . dirname ( box . stateFile ), { recursive : true });
fs . writeFileSync ( box . stateFile , JSON . stringify ({ lastCli : "goose" }));
assert . equal ( box . run ([]). status , 0 );
assert . notEqual ( box . argsOf ( "goose" ), null );
assert . equal ( box . argsOf ( "claude" ), null );
const bad = box . run ([ "--cli" , "bogus" ]);
assert . equal ( bad . status , 2 );
assert . match ( bad . stderr , /--cli takes claude, devin, codex or goose, not "bogus"/ );
});
test ( "launcher agents: the model menu is the agent's own models, with no shipped list or user models.json" , ( t ) => {
const box = sandbox ([]);
t . after ( box . cleanup );
fs . mkdirSync ( path . join ( box . home , ".plan2code" ), { recursive : true });
const file = writeAgents ( box , goose ());
const { customClis , listModels , hasModelFlag } = require ( LAUNCHER );
const [ cli ] = customClis ( file , false );
assert . deepEqual ( listModels ( cli ), [{ id : "m1" , label : "Model one" }, { id : "m2" , label : "" }]);
assert . deepEqual ( listModels ( customClis ( writeAgents ( box , goose ({ models : [] })), false )[ 0 ]), []);
// Only --model counts for a custom agent: Codex's -m does not.
assert . equal ( hasModelFlag ([ "--model" , "x" ], "goose" ), true );
assert . equal ( hasModelFlag ([ "-m" , "x" ], "goose" ), false );
// A model given on the command line goes through modelArgs, once.
2026-10-27 18:20:31 -07:00
assert . deepEqual ( cli . args ([ "--model=m2" , "-x" ], { bypass : true }), [ "--yes" , "/plan2code" , "--model" , "m2" , "--bypass" , "-x" ]);
assert . deepEqual ( cli . args ([ "-x" ]), [ "--yes" , "/plan2code" , "-x" ]);
2026-10-25 21:26:08 -07:00
});
2026-10-26 06:36:45 -07:00
test ( "launcher agents: the menu lists the built-ins found first, then the custom agents that resolve" , ( t ) => {
const box = sandbox ([ "goose" , "codex" , "claude" ]);
t . after ( box . cleanup );
const file = writeAgents ( box , { schema : 1 , agents : [ GOOSE , { id : "ghost" , name : "Ghost" , command : "ghost-cmd" }] });
const { customClis , runnableClis } = require ( LAUNCHER );
const realPath = process . env . PATH ;
process . env . PATH = path . join ( box . dir , "bin" );
t . after (() => {
process . env . PATH = realPath ;
});
const { installed , missing } = runnableClis ( customClis ( file , false ));
assert . deepEqual ( installed . map (( cli ) => cli . id ), [ "claude" , "codex" , "goose" ]);
assert . deepEqual ( missing . map (( cli ) => cli . id ), [ "ghost" ]);
});
test ( "launcher agents: with no terminal to ask, a custom agent's model line names its own default" , ( t ) => {
const box = sandbox ([ "goose" ]);
t . after ( box . cleanup );
writeAgents ( box , goose ());
const result = box . run ([ "--cli" , "goose" ]);
assert . equal ( result . status , 0 , result . stderr );
assert . match ( result . stdout , /Goose will start with its own default model\. To pick one, run `plan2code --model <id>`\./ );
assert . doesNotMatch ( result . stdout , /last used/ );
});
2026-10-25 21:26:08 -07:00
test ( "launcher agents: a custom agent whose command is not found is left out and named when nothing can run" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
writeAgents ( box , { schema : 1 , agents : [{ id : "ghost" , name : "Ghost" , command : "ghost-cmd" }] });
// Left out of the way: claude still starts.
assert . equal ( box . run ([]). status , 0 );
assert . notEqual ( box . argsOf ( "claude" ), null );
const asked = box . run ([ "--cli" , "ghost" ]);
assert . equal ( asked . status , 127 );
assert . match ( asked . stderr , /Custom agent Ghost: ghost-cmd not found/ );
const none = sandbox ([]);
t . after ( none . cleanup );
writeAgents ( none , { schema : 1 , agents : [{ id : "ghost" , name : "Ghost" , command : "ghost-cmd" }] });
const result = none . run ([]);
assert . equal ( result . status , 127 );
assert . match ( result . stderr , /Custom agent Ghost: ghost-cmd not found/ );
2026-11-03 03:21:20 -08:00
assert . ok ( result . stderr . includes ( "agents.json" ));
2026-10-25 21:26:08 -07:00
});
test ( "launcher agents: a malformed agents.json warns on a terminal, never crashes, and gives no agents" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const file = writeAgents ( box , "{ not json" );
const { customClis } = require ( LAUNCHER );
const lines = [];
const realError = console . error ;
console . error = ( line ) => lines . push ( String ( line ));
try {
assert . deepEqual ( customClis ( file , true ), []);
assert . deepEqual ( customClis ( path . join ( box . home , "missing.json" ), true ), []);
} finally {
console . error = realError ;
}
assert . equal ( lines . length , 1 );
assert . match ( lines [ 0 ], /plan2code: agents\.json: agents\.json is not valid JSON/ );
// A piped run prints no warning, and the built-ins carry on.
const result = box . run ([]);
assert . equal ( result . status , 0 , result . stderr );
assert . equal ( result . stderr , "" );
assert . notEqual ( box . argsOf ( "claude" ), null );
});
test ( "launcher agents: the app hand-over passes a custom id and its model unchanged" , ( t ) => {
const box = sandbox ([ "goose" ]);
t . after ( box . cleanup );
writeAgents ( box , goose ());
const display = process . platform === "linux" ? { DISPLAY : ":0" } : {};
const result = box . run ([ "--cli" , "goose" , "--model" , "m2" ], { PLAN2CODE_APP : box . appFile , ... display });
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . appArgs (). slice ( 2 ), [ "--agent" , "goose" , "--model" , "m2" ]);
assert . equal ( box . argsOf ( "goose" ), null );
assert . equal ( JSON . parse ( fs . readFileSync ( box . stateFile , "utf8" )). lastCli , "goose" );
});
2026-11-03 03:21:20 -08:00
/* ------------------------- the shipped agent list (installed layout) ------------------------- */
const OS_KEY = IS_WINDOWS ? "win" : process . platform === "darwin" ? "mac" : "linux" ;
const SHIPPED_AGENTS = JSON . parse ( fs . readFileSync ( path . join ( path . dirname ( LAUNCHER ), "agents.json" ), "utf8" ));
const builtin = ( id ) => SHIPPED_AGENTS . agents . find (( a ) => a . id === id );
const leadRun = ( id ) => builtin ( id ). install [ OS_KEY ][ 0 ]. run ;
test ( "launcher list: the menu and launch come from the sandboxed agents.json + agent-lookup.mjs" , ( t ) => {
const box = sandbox ([ "claude" , "devin" , "codex" ], { installed : "0.0.0" });
t . after ( box . cleanup );
2026-11-08 13:48:28 -08:00
const result = box . run ([ "--cli" , "devin" , "--bypass-permissions" , "--verbose" ]);
2026-11-03 03:21:20 -08:00
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "devin" ), [ "--permission-mode" , "bypass" , "--verbose" , "--" , "/plan2code" ]);
// The menu's order and shape come from the list: --cli errors list the same ids.
const bad = box . run ([ "--cli" , "bogus" ]);
assert . equal ( bad . status , 2 );
assert . match ( bad . stderr , /--cli takes claude, devin or codex, not "bogus"/ );
});
test ( "launcher list: a forwarded --model fills {model} in place; Codex's -m forwards untouched" , ( t ) => {
const box = sandbox ([ "claude" , "codex" ], { installed : "0.0.0" });
t . after ( box . cleanup );
assert . equal ( box . run ([ "--cli" , "claude" , "--model" , "opus" ]). status , 0 );
2026-11-08 13:48:28 -08:00
assert . deepEqual ( box . argsOf ( "claude" ), [ "/plan2code" , "--model" , "opus" ]);
2026-11-03 03:21:20 -08:00
assert . equal ( box . run ([ "--cli" , "codex" , "-m" , "x" ]). status , 0 );
2026-11-08 13:48:28 -08:00
assert . deepEqual ( box . argsOf ( "codex" ), [ "-m" , "x" , "$plan2code" ]);
2026-11-03 03:21:20 -08:00
});
test ( "launcher list: the last-used notice names the gone agent and the pick, on a terminal only" , () => {
const { lastUsedNotice } = require ( LAUNCHER );
const all = [
{ id : "claude" , label : "Claude Code" },
{ id : "devin" , label : "Devin" },
];
const installed = [ all [ 0 ]];
assert . equal ( lastUsedNotice ( installed , all , "devin" ), "Devin (last used) was not found, using Claude Code" );
assert . equal ( lastUsedNotice ( installed , all , "claude" ), null , "still runnable" );
assert . equal ( lastUsedNotice ( installed , all , "ghost" ), "ghost (last used) was not found, using Claude Code" );
assert . equal ( lastUsedNotice ([], all , "devin" ), null , "nothing to use" );
assert . equal ( lastUsedNotice ( installed , all , undefined ), null );
});
test ( "launcher list: a missing agent-lookup.mjs falls back to the built-in list" , ( t ) => {
const box = sandbox ([ "claude" ], { installed : "0.0.0" , lookup : false });
t . after ( box . cleanup );
const result = box . run ([]);
assert . equal ( result . status , 0 , result . stderr );
2026-11-08 13:48:28 -08:00
assert . deepEqual ( box . argsOf ( "claude" ), [ "/plan2code" ]);
2026-11-03 03:21:20 -08:00
});
test ( "launcher list: with no agent and no terminal it prints this OS's install steps and exits 127" , ( t ) => {
const box = sandbox ([], { installed : "0.0.0" });
t . after ( box . cleanup );
const result = box . run ([]);
assert . equal ( result . status , 127 );
for ( const id of [ "claude" , "devin" , "codex" ]) {
assert . ok ( result . stderr . includes ( leadRun ( id )), ` ${ id } : ${ leadRun ( id ) } ` );
assert . ok ( result . stderr . includes ( builtin ( id ). installUrl ), id );
}
assert . ok ( result . stderr . includes ( "add another agent by editing `~/.plan2code/agents.json`, then run `plan2code` again" ) || result . stderr . includes ( "Add it by editing `~/.plan2code/agents.json`, then run `plan2code` again." ));
assert . doesNotMatch ( result . stderr , /User Preferences/ );
});
test ( "launcher list: --cli for a missing built-in prints its lead install line and exits 127" , ( t ) => {
const box = sandbox ([ "claude" ], { installed : "0.0.0" });
t . after ( box . cleanup );
const result = box . run ([ "--cli" , "devin" ]);
assert . equal ( result . status , 127 );
assert . match ( result . stderr , /the `devin` CLI was not found/ );
assert . ok ( result . stderr . includes ( leadRun ( "devin" )), leadRun ( "devin" ));
assert . ok ( result . stderr . includes ( builtin ( "devin" ). installUrl ));
});
2026-10-25 21:26:08 -07:00
test ( "launcher agents: a full-path command starts, and on Windows a .cmd in a folder with a space too" , ( t ) => {
const box = sandbox ([]);
t . after ( box . cleanup );
const spaced = path . join ( box . dir , "with space" );
fs . mkdirSync ( spaced );
const recorder = path . join ( box . dir , "bin" , "record.js" );
let file ;
if ( IS_WINDOWS ) {
file = path . join ( spaced , "spaced.cmd" );
fs . writeFileSync ( file , `@" ${ process . execPath } " " ${ recorder } " spaced %*\r\n` );
2026-10-26 06:36:45 -07:00
// A same-named file in the project folder (the launcher's cwd) must not run instead.
fs . writeFileSync ( path . join ( box . dir , "spaced.cmd" ), `@" ${ process . execPath } " " ${ recorder } " decoy %*\r\n` );
2026-10-25 21:26:08 -07:00
} else {
file = path . join ( spaced , "spaced" );
fs . writeFileSync ( file , `#!/bin/sh\nexec " ${ process . execPath } " " ${ recorder } " spaced "$@"\n` );
fs . chmodSync ( file , 0o755 );
}
writeAgents ( box , { schema : 1 , agents : [{ id : "spaced" , name : "Spaced" , command : file , args : [ "{prompt}" ] }] });
2026-10-26 06:36:45 -07:00
// Some shells already set the switch the launcher sets; the run starts without it.
const result = box . run ([ "--cli" , "spaced" , "--note" , "a b" ], { NoDefaultCurrentDirectoryInExePath : undefined });
2026-10-25 21:26:08 -07:00
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( box . argsOf ( "spaced" ), [ "/plan2code" , "--note" , "a b" ]);
2026-10-26 06:36:45 -07:00
assert . equal ( box . argsOf ( "decoy" ), null );
2026-10-25 21:26:08 -07:00
});
2026-11-03 03:21:20 -08:00
/* ------------------------- first-run setup (the browser setup page) ------------------------- */
// When no agent can run and a person can see a page, the launcher opens the console's
// agent-less `setup` workflow (`open --workflow setup`, plus `--for-cli` when one agent
// was asked for), then waits on the session until a send carries `__start`. These drive
// runSetupFlow() directly against a stand-in console.mjs that records each call and
// answers `wait` from a step list in P2C_FAKE_STEPS.
// The app-window variables scrubbedEnv() must strip from the console child (NFR-2).
const APP_VARS = [
"PLAN2CODE_IN_APP" ,
"PLAN2CODE_APP_TOKEN" ,
"PLAN2CODE_APP_ANNOUNCE" ,
"PLAN2CODE_EMBED_ORIGIN" ,
"PLAN2CODE_CONSOLE_SID" ,
"PLAN2CODE_APP_VERSION" ,
];
// The stand-in console: every call is recorded (argv plus which app vars leaked through),
// `open` prints a setup session's JSON, `wait` plays back the numbered step. A step the
// test forgot to write ends as a Cancel rather than hanging the four-hour cap.
const FAKE_CONSOLE = [
'import fs from "node:fs";' ,
'import path from "node:path";' ,
'const dir = path.dirname(process.argv[1]);' ,
`const APP = ${ JSON . stringify ( APP_VARS ) } ;` ,
'fs.appendFileSync(path.join(dir, "calls.jsonl"), JSON.stringify({ argv: process.argv.slice(2), appVars: APP.filter((k) => k in process.env) }) + "\\n");' ,
'if (process.argv[2] === "open") {' ,
' console.log(JSON.stringify({ sid: "setup-sid", url: "http://127.0.0.1:9/s/signtok/", setup: { url: "http://127.0.0.1:9/s/signtok/", token: "handover-tok" } }));' ,
'} else if (process.argv[2] === "wait") {' ,
' const file = path.join(dir, "waits");' ,
' const n = fs.existsSync(file) ? Number(fs.readFileSync(file, "utf8")) : 0;' ,
' fs.writeFileSync(file, String(n + 1));' ,
' const steps = JSON.parse(process.env.P2C_FAKE_STEPS || "[]");' ,
' const step = steps[n] || { exit: 30 };' ,
' if (step.print) console.log(JSON.stringify(step.print));' ,
' process.exit(step.exit === undefined ? 0 : step.exit);' ,
'}' ,
]. join ( "\n" );
// A folder holding the stand-in console.mjs (the wait counter lives beside it); calls()
// replays what it was asked, oldest first.
function setupConsoleDir () {
const dir = fs . mkdtempSync ( path . join ( os . tmpdir (), "p2c-setup-console-" ));
fs . writeFileSync ( path . join ( dir , "console.mjs" ), FAKE_CONSOLE );
return {
dir ,
calls : () =>
fs . existsSync ( path . join ( dir , "calls.jsonl" ))
? fs . readFileSync ( path . join ( dir , "calls.jsonl" ), "utf8" ). trim (). split ( "\n" ). map ( JSON . parse )
: [],
cleanup : () => fs . rmSync ( dir , { recursive : true , force : true }),
};
}
// Point the console search at the stand-in and hand it the wait steps; restores
// PLAN2CODE_CONSOLE_DIR, P2C_FAKE_STEPS and any app vars `extra` set afterwards.
function setupEnv ( t , dir , steps , extra = {}) {
const keys = [ "PLAN2CODE_CONSOLE_DIR" , "P2C_FAKE_STEPS" , ... APP_VARS ];
const saved = Object . fromEntries ( keys . map (( k ) => [ k , process . env [ k ]]));
process . env . PLAN2CODE_CONSOLE_DIR = dir ;
process . env . P2C_FAKE_STEPS = JSON . stringify ( steps );
for ( const [ k , v ] of Object . entries ( extra )) process . env [ k ] = v ;
t . after (() => {
for ( const k of keys ) {
if ( saved [ k ] === undefined ) delete process . env [ k ];
else process . env [ k ] = saved [ k ];
}
});
}
// A builtin-shaped list for runSetupFlow's re-lookup, and the send that starts claude.
const SETUP_CLIS = [{ id : "claude" , label : "Claude Code" , entry : { command : "claude" } }];
const START_CLAUDE = { print : { session : [{ i : "__start" , agent : "claude" }] }, exit : 0 };
const foundAt = ( file ) => () => ({ state : "found" , path : file });
test ( "launcher setup: a Start re-finds the agent and hands back the announce address and token" , ( t ) => {
const box = setupConsoleDir ();
t . after ( box . cleanup );
setupEnv ( t , box . dir , [ START_CLAUDE ]);
const { runSetupFlow } = require ( LAUNCHER );
const agentPath = path . join ( box . dir , "claude.exe" );
const out = runSetupFlow ( "claude" , SETUP_CLIS , foundAt ( agentPath ));
assert . equal ( out . cli . id , "claude" );
assert . equal ( out . cli . path , agentPath , "the named agent is looked up again after the Start" );
assert . deepEqual ( out . setup , { announce : "http://127.0.0.1:9/s/signtok/" , token : "handover-tok" });
assert . deepEqual (
box . calls (). map (( c ) => c . argv ),
[
[ "open" , "--workflow" , "setup" , "--for-cli" , "claude" ],
[ "wait" , "--session" , "setup-sid" , "--seconds" , "240" ],
]
);
});
test ( "launcher setup: the console is spawned without the six app-window variables" , ( t ) => {
const box = setupConsoleDir ();
t . after ( box . cleanup );
// Every one set on this process: none may reach the console child.
setupEnv ( t , box . dir , [ START_CLAUDE ], Object . fromEntries ( APP_VARS . map (( k ) => [ k , "live" ])));
const { runSetupFlow } = require ( LAUNCHER );
runSetupFlow ( undefined , SETUP_CLIS , foundAt ( path . join ( box . dir , "claude.exe" )));
const calls = box . calls ();
assert . deepEqual ( calls [ 0 ]. argv , [ "open" , "--workflow" , "setup" ], "no --for-cli without a named agent" );
for ( const call of calls ) assert . deepEqual ( call . appVars , [], `app vars leaked into the console's ${ call . argv [ 0 ] } ` );
});
test ( "launcher setup: a send that is not a Start and a still-waiting slice keep the wait going" , ( t ) => {
const box = setupConsoleDir ();
t . after ( box . cleanup );
setupEnv ( t , box . dir , [
{ print : { session : [{ i : "q1" , type : "answer" , kind : "choice" , k : "A" }] }, exit : 0 },
{ exit : 10 },
START_CLAUDE ,
]);
const { runSetupFlow } = require ( LAUNCHER );
const out = runSetupFlow ( undefined , SETUP_CLIS , foundAt ( path . join ( box . dir , "claude.exe" )));
assert . equal ( out . cli . id , "claude" );
assert . equal ( box . calls (). filter (( c ) => c . argv [ 0 ] === "wait" ). length , 3 , "exit 10 re-runs the wait, exit 0 without a Start keeps it" );
});
test ( "launcher setup: cancel, a gone server and a Start for an agent that still cannot run all end as 127" , ( t ) => {
const { runSetupFlow } = require ( LAUNCHER );
const cases = [
[ "cancel" , [{ exit : 30 }]],
[ "server gone" , [{ exit : 20 }]],
[ "Start for an agent the re-lookup misses" , [{ print : { session : [{ i : "__start" , agent : "ghost-cli" }] }, exit : 0 }]],
];
for ( const [ name , steps ] of cases ) {
const box = setupConsoleDir ();
t . after ( box . cleanup );
setupEnv ( t , box . dir , steps );
const out = runSetupFlow ( undefined , SETUP_CLIS , foundAt ( path . join ( box . dir , "claude.exe" )));
assert . deepEqual ( out , { code : 127 }, name );
}
});
test ( "launcher setup: an older console's open line still yields the announce address and token from the url" , ( t ) => {
const dir = fs . mkdtempSync ( path . join ( os . tmpdir (), "p2c-setup-console-" ));
t . after (() => fs . rmSync ( dir , { recursive : true , force : true }));
// No setup block in the open output: sid and the /s/<token>/ url alone must do.
fs . writeFileSync (
path . join ( dir , "console.mjs" ),
[
'if (process.argv[2] === "open") {' ,
' console.log(JSON.stringify({ sid: "setup-sid", url: "http://127.0.0.1:9/s/signtok/" }));' ,
'} else if (process.argv[2] === "wait") {' ,
' console.log(JSON.stringify({ session: [{ i: "__start", agent: "claude" }] }));' ,
'}' ,
]. join ( "\n" )
);
setupEnv ( t , dir , []);
const out = require ( LAUNCHER ). runSetupFlow ( undefined , SETUP_CLIS , foundAt ( "x" ));
assert . equal ( out . cli . id , "claude" );
assert . deepEqual ( out . setup , { announce : "http://127.0.0.1:9" , token : "signtok" });
});
test ( "launcher setup: with no console.mjs anywhere, runSetupFlow returns null rather than guessing" , ( t ) => {
const launcherPath = require . resolve ( LAUNCHER );
const home = fs . mkdtempSync ( path . join ( os . tmpdir (), "p2c-no-console-" ));
t . after (() => fs . rmSync ( home , { recursive : true , force : true }));
// Every place findConsoleMjs() looks is derived from the home or
// PLAN2CODE_CONSOLE_DIR, so a fresh module under an empty home finds nothing.
const keys = [ "HOME" , "USERPROFILE" , "PLAN2CODE_CONSOLE_HOME" , "PLAN2CODE_CONSOLE_DIR" ];
const saved = Object . fromEntries ( keys . map (( k ) => [ k , process . env [ k ]]));
delete require . cache [ launcherPath ];
try {
process . env . HOME = home ;
process . env . USERPROFILE = home ;
delete process . env . PLAN2CODE_CONSOLE_HOME ;
delete process . env . PLAN2CODE_CONSOLE_DIR ;
assert . equal ( require ( LAUNCHER ). runSetupFlow ( "claude" , SETUP_CLIS , foundAt ( "x" )), null );
} finally {
for ( const k of keys ) {
if ( saved [ k ] === undefined ) delete process . env [ k ];
else process . env [ k ] = saved [ k ];
}
// Re-require with the real home so later tests see the host's own module.
delete require . cache [ launcherPath ];
require ( LAUNCHER );
}
});
test ( "launcher setup: a Start can name a custom agent; the launcher re-reads ~/.plan2code/agents.json" , ( t ) => {
const launcherPath = require . resolve ( LAUNCHER );
const home = fs . mkdtempSync ( path . join ( os . tmpdir (), "p2c-setup-home-" ));
const box = setupConsoleDir ();
t . after (() => {
fs . rmSync ( home , { recursive : true , force : true });
box . cleanup ();
});
// USER_AGENTS_FILE is fixed at require time from the home, so the module needs
// a fresh instance whose home is the scratch one.
const keys = [ "HOME" , "USERPROFILE" , "PLAN2CODE_CONSOLE_HOME" ];
const saved = Object . fromEntries ( keys . map (( k ) => [ k , process . env [ k ]]));
delete require . cache [ launcherPath ];
try {
process . env . HOME = home ;
process . env . USERPROFILE = home ;
process . env . PLAN2CODE_CONSOLE_HOME = path . join ( home , ".plan2code" , "console" );
const { runSetupFlow } = require ( LAUNCHER );
const agent = path . join ( box . dir , "myagent.cmd" );
fs . writeFileSync ( agent , "@rem stand-in\r\n" );
fs . mkdirSync ( path . join ( home , ".plan2code" ), { recursive : true });
fs . writeFileSync (
path . join ( home , ".plan2code" , "agents.json" ),
JSON . stringify ({ schema : 1 , agents : [{ id : "myagent" , name : "My Agent" , command : agent , args : [ "{prompt}" ] }] })
);
setupEnv ( t , box . dir , [{ print : { session : [{ i : "__start" , agent : "myagent" }] }, exit : 0 }]);
const out = runSetupFlow ( undefined , [], null );
assert . equal ( out . cli . id , "myagent" );
assert . equal ( out . cli . custom , true );
assert . equal ( out . cli . path , agent );
assert . equal ( out . cli . fullPath , true );
} finally {
for ( const k of keys ) {
if ( saved [ k ] === undefined ) delete process . env [ k ];
else process . env [ k ] = saved [ k ];
}
delete require . cache [ launcherPath ];
require ( LAUNCHER );
}
});
test ( "launcher setup: with the app installed and no agent runnable, the app opens on the folder alone" , ( t ) => {
const box = sandbox ([], { installed : "0.0.0" });
t . after ( box . cleanup );
// npm's real global folder could hold a real agent; an empty prefix keeps "none runnable" certain.
const display = process . platform === "linux" ? { DISPLAY : ":0" } : {};
const result = box . run ([], { PLAN2CODE_APP : box . appFile , npm_config_prefix : path . join ( box . dir , "no-npm" ), ... display });
assert . equal ( result . status , 0 , result . stderr );
const appArgs = box . appArgs ();
assert . ok ( appArgs , "the stand-in app was never started" );
assert . equal ( appArgs [ 0 ], "--project" );
assert . equal ( fs . realpathSync ( appArgs [ 1 ]), fs . realpathSync ( box . dir ));
assert . deepEqual ( appArgs . slice ( 2 ), [], "no --agent and no --model when none can run" );
assert . match ( result . stdout , /Opened the Plan2Code app/ );
});
test ( "launcher setup: no agent and no display keeps the old 127 and install steps" , { skip : process . platform !== "linux" }, ( t ) => {
const box = sandbox ([], { installed : "0.0.0" });
t . after ( box . cleanup );
const result = box . run ([], { PLAN2CODE_APP : box . appFile , DISPLAY : "" , WAYLAND_DISPLAY : "" , npm_config_prefix : path . join ( box . dir , "no-npm" ) });
assert . equal ( result . status , 127 );
assert . match ( result . stderr , /none was found/ );
assert . equal ( box . appExists (), false );
});
2026-11-15 11:22:58 -08:00
// The recent-folders rule: the same cases the desktop app's project.rs loads (the fixture holds
// both platforms' rules, so each runs on every OS: "win32" and "linux" are passed explicitly).
const RECENT_CASES = JSON . parse ( fs . readFileSync ( path . join ( ROOT , "scripts" , "fixtures" , "recent-folders-cases.json" ), "utf8" ));
const RECENT_PLATFORMS = { win32 : "win32" , posix : "linux" };
/** The platform values ("win32" or "linux") a fixture case runs under. */
function recentPlatforms ( testCase ) {
return testCase . platform ? [ RECENT_PLATFORMS [ testCase . platform ]] : [ "win32" , "linux" ];
}
test ( "launcher recent folders: readRecent follows the shared cases" , () => {
const { readRecent } = require ( LAUNCHER );
assert . ok ( RECENT_CASES . read . length > 0 );
for ( const c of RECENT_CASES . read ) assert . deepEqual ( readRecent ( c . state ), c . expect , c . name );
});
test ( "launcher recent folders: pushRecent follows the shared cases" , () => {
const { pushRecent } = require ( LAUNCHER );
assert . ok ( RECENT_CASES . push . length > 0 );
for ( const c of RECENT_CASES . push ) {
for ( const platform of recentPlatforms ( c )) assert . deepEqual ( pushRecent ( c . list , c . dir , platform ), c . expect , ` ${ c . name } ( ${ platform } )` );
}
});
test ( "launcher recent folders: listRecent follows the shared cases" , () => {
const { listRecent } = require ( LAUNCHER );
assert . ok ( RECENT_CASES . list . length > 0 );
for ( const c of RECENT_CASES . list ) {
const exists = new Set ( c . exists );
for ( const platform of recentPlatforms ( c )) {
assert . deepEqual ( listRecent ( c . list , { exists : ( p ) => exists . has ( p ), exclude : c . exclude , platform }), c . expect , ` ${ c . name } ( ${ platform } )` );
}
}
});
test ( "launcher recent folders: pushRecent returns a new array and leaves its input alone" , () => {
const { pushRecent } = require ( LAUNCHER );
const list = [ "/b" , "/a" ];
pushRecent ( list , "/c" , "linux" );
assert . deepEqual ( list , [ "/b" , "/a" ]);
});
test ( "launcher recent folders: recordFolder writes both keys from a state with only lastFolder and keeps the rest" , ( t ) => {
const box = sandbox ([]);
t . after ( box . cleanup );
fs . mkdirSync ( path . dirname ( box . stateFile ), { recursive : true });
fs . writeFileSync ( box . stateFile , JSON . stringify ({ lastFolder : "/old" , lastCli : "devin" }));
const picked = path . join ( box . dir , "picked" );
const script = `require( ${ JSON . stringify ( LAUNCHER ) } ).recordFolder( ${ JSON . stringify ( picked ) } );` ;
const result = spawnSync ( process . execPath , [ "-e" , script ], {
encoding : "utf8" ,
env : { ... process . env , HOME : box . home , USERPROFILE : box . home },
});
assert . equal ( result . status , 0 , result . stderr );
assert . deepEqual ( JSON . parse ( fs . readFileSync ( box . stateFile , "utf8" )), {
lastFolder : picked ,
recentFolders : [ picked , "/old" ],
lastCli : "devin" ,
});
});
test ( "launcher folder menu: from the command, the current folder comes first, then the recents, then browse" , () => {
const { folderMenuRows } = require ( LAUNCHER );
const cwd = path . join ( os . tmpdir (), "here" );
const recent = [ path . join ( os . tmpdir (), "one" ), path . join ( os . tmpdir (), "two" )];
assert . deepEqual ( folderMenuRows ({ fromShortcut : false , cwd , recent }), [
{ kind : "folder" , dir : cwd , name : "here" , detail : ` ${ cwd } (current folder)` , label : `here ${ cwd } (current folder)` },
{ kind : "folder" , dir : recent [ 0 ], name : "one" , detail : recent [ 0 ], label : `one ${ recent [ 0 ] } ` },
{ kind : "folder" , dir : recent [ 1 ], name : "two" , detail : recent [ 1 ], label : `two ${ recent [ 1 ] } ` },
{ kind : "browse" , label : "Choose another folder..." },
]);
});
test ( "launcher folder menu: from the shortcut, browse comes first, then the recents" , () => {
const { folderMenuRows } = require ( LAUNCHER );
const recent = [ path . join ( os . tmpdir (), "one" )];
assert . deepEqual ( folderMenuRows ({ fromShortcut : true , cwd : os . tmpdir (), recent }), [
{ kind : "browse" , label : "Choose a folder..." },
{ kind : "folder" , dir : recent [ 0 ], name : "one" , detail : recent [ 0 ], label : `one ${ recent [ 0 ] } ` },
]);
});
test ( "launcher folder menu: a drive root keeps its full text as its name" , () => {
const { folderMenuRows } = require ( LAUNCHER );
const root = path . parse ( process . cwd ()). root ;
const [ row ] = folderMenuRows ({ fromShortcut : false , cwd : root , recent : [] });
assert . equal ( row . label , ` ${ root } ${ root } (current folder)` );
assert . equal ( row . name , root );
assert . equal ( row . detail , ` ${ root } (current folder)` );
});
test ( "launcher folder menu: Enter picks row 1, a number its row, anything else asks again" , () => {
const { folderMenuPick } = require ( LAUNCHER );
const rows = [{ kind : "folder" , dir : "/a" , label : "a" }, { kind : "folder" , dir : "/b" , label : "b" }, { kind : "browse" , label : "x" }];
assert . equal ( folderMenuPick ( rows , "" ), rows [ 0 ]);
assert . equal ( folderMenuPick ( rows , " " ), rows [ 0 ]);
assert . equal ( folderMenuPick ( rows , "2" ), rows [ 1 ]);
assert . equal ( folderMenuPick ( rows , " 3 " ), rows [ 2 ]);
for ( const answer of [ "0" , "9" , "x" , "1.5" , "-1" ]) assert . equal ( folderMenuPick ( rows , answer ), null , answer );
});
test ( "launcher folder menu: with recent folders but no terminal, it starts in the current folder without a menu and records it" , ( t ) => {
const box = sandbox ([ "claude" ]);
t . after ( box . cleanup );
const older = path . join ( box . dir , "older" );
fs . mkdirSync ( older );
fs . mkdirSync ( path . dirname ( box . stateFile ), { recursive : true });
fs . writeFileSync ( box . stateFile , JSON . stringify ({ recentFolders : [ older ], lastFolder : older , lastCli : "claude" }));
const result = box . run ([]);
assert . equal ( result . status , 0 , result . stderr );
assert . doesNotMatch ( result . stdout , /Which project folder\?/ );
assert . doesNotMatch ( result . stdout , /Opening Plan2Code in/ );
assert . notEqual ( box . argsOf ( "claude" ), null );
const { recentFolders , lastFolder , ... rest } = JSON . parse ( fs . readFileSync ( box . stateFile , "utf8" ));
assert . deepEqual ( rest , { lastCli : "claude" });
assertRecordedFirst ({ recentFolders , lastFolder }, box . dir , [ older ]);
});
test ( "launcher folder menu: a folder that fails the project check is not recorded" , ( t ) => {
const box = sandbox ([ "claude" ], { project : false });
t . after ( box . cleanup );
const older = path . join ( box . dir , "older" );
fs . mkdirSync ( older );
fs . mkdirSync ( path . dirname ( box . stateFile ), { recursive : true });
const state = { recentFolders : [ older ], lastFolder : older , lastCli : "claude" };
fs . writeFileSync ( box . stateFile , JSON . stringify ( state ));
const result = box . run ([]);
assert . equal ( result . status , 0 , result . stderr );
assert . match ( result . stderr , /doesn't look like a project/ );
assert . equal ( box . argsOf ( "claude" ), null );
assert . deepEqual ( JSON . parse ( fs . readFileSync ( box . stateFile , "utf8" )), state );
});