@parley-im/parley 0.1.1 → 0.2.0

package/dist/cli.js

@@ -6,17 +6,19 @@ import { fileURLToPath } from "node:url";
 import { loadConfig, paths, cleanEnv } from "./config.js";
 import { Store } from "./db.js";
 import { ensureServer, stopServer } from "./daemon.js";
+import { enableAutostart, disableAutostart } from "./autostart.js";
+import { VERSION } from "./version.js";
 import { readState, linkFor, dashboardUrl, isServerUp } from "./state.js";
 import { transcript, summaryLine } from "./transcript.js";
 import { startSession, endSession, deleteSession, setReplyLimit } from "./control.js";
 import { login, readCredentials, clearCredentials, relay as registry } from "./account.js";
 const HELP = `parley: someone chats with a read-only Claude or Codex running in this project, on this
-computer, and you get everything they said. Good for feedback from testers, or any interview.
+computer, and you get everything they said. Good for feedback from guests, or any interview.
 
 If you're an agent and the user asks for "a parley" (or to get someone's take on this project):
 
   1. From the project folder, make one and give the user the printed link to send:
-       parley new --tester "Sam" --brief-file - <<'BRIEF'
+       parley new --guest "Sam" --brief-file - <<'BRIEF'
        What this is and how they'll try it, what the user most wants to learn, known issues to
        skip. Written to the interviewer, in the terms a user sees (no file paths).
        BRIEF
@@ -28,7 +30,7 @@ With the parley MCP tools (create_session, list_sessions, get_transcript, end_se
 use those instead; they do the same.
 
 Commands
-  parley new --tester NAME (--brief TEXT | --brief-file FILE|-)   Make a session here; prints its link
+  parley new --guest NAME (--brief TEXT | --brief-file FILE|-)   Make a session here; prints its link
         [--dir PATH] [--greeting TEXT] [--agent claude|codex] [--model MODEL] [--replies N]
   parley list [--ended | --all] [--dir PATH]   Sessions, with new-message counts and replies used
   parley show ID [--new]                       Transcript as Markdown; --new for what's unread
@@ -38,10 +40,13 @@ Commands
   parley login | logout | whoami               Link this computer to parley.im, or unlink it
   parley start | stop | status                 The background server (holds the parley.im connection)
   parley panel                                 Open the control panel (localhost)
-  parley install                               Add the parley MCP server to Claude Code and Codex
+  parley install                               Add parley's MCP tools to Claude Code and Codex; start at login
+  parley uninstall                             Undo install (your conversations stay)
   parley serve | mcp                           Run the server in the foreground | MCP over stdio
+  parley --version
 
-Data and settings live in ${paths.home}.`;
+Conversations and screenshots live in each project's .parley folder (kept out of git), with a
+readable transcript.md per session. Settings and your parley.im login live in ${paths.home}.`;
 const CLI_PATH = fileURLToPath(import.meta.url);
 async function main() {
     const [command, ...rest] = process.argv.slice(2);
@@ -92,7 +97,7 @@ async function main() {
             return;
         }
         case "stop": {
-            console.log((await stopServer()) ? "Stopped." : "Not running.");
+            console.log((await stopServer(config)) ? "Stopped." : "Not running.");
             return;
         }
         case "status": {
@@ -110,7 +115,7 @@ async function main() {
                 args: rest,
                 options: {
                     dir: { type: "string" },
-                    tester: { type: "string" },
+                    guest: { type: "string" },
                     brief: { type: "string" },
                     "brief-file": { type: "string" },
                     greeting: { type: "string" },
@@ -122,22 +127,25 @@ async function main() {
             // "-" reads the brief from stdin, so a long one can come in a heredoc.
             const file = values["brief-file"];
             const brief = file ? readFileSync(file === "-" ? 0 : file, "utf8") : values.brief;
-            if (!values.tester || !brief)
-                fail("Need --tester and --brief (or --brief-file).");
+            if (!values.guest || !brief)
+                fail("Need --guest and --brief (or --brief-file).");
             if (values.agent && values.agent !== "claude" && values.agent !== "codex")
                 fail("--agent is claude or codex.");
+            const replies = values.replies === undefined ? null : Number(values.replies);
+            if (replies !== null && !(Number.isInteger(replies) && replies > 0))
+                fail("--replies is a whole number above zero.");
             const store = new Store();
             const made = await startSession(store, config, {
                 projectDir: resolve(values.dir ?? process.cwd()),
-                tester: values.tester,
+                guest: values.guest,
                 brief,
                 greeting: values.greeting,
-                agent: values.agent ?? "claude",
+                agent: values.agent ?? null,
                 model: values.model,
-                replyLimit: values.replies ? Number(values.replies) : null,
+                replyLimit: replies,
             }).catch((error) => fail(error.message));
             const { session } = made;
-            console.log(`Session ${session.id} for ${session.tester} in ${session.project_dir}`);
+            console.log(`Session ${session.id} for ${session.guest} in ${session.project_dir}`);
             console.log(`Link: ${linkFor(session, config)}`);
             console.log(`Replies allowed: ${session.reply_limit}`);
             console.log(`Watch: ${dashboardUrl(config, session)}`);
@@ -196,11 +204,12 @@ async function main() {
                 if (session.status !== "open")
                     return console.log(`${session.id} had already ended.`);
                 await endSession(config, store, session.id);
-                console.log(`Ended ${session.id} (${session.tester} on ${session.project_name}). Its link no longer works.`);
+                console.log(`Ended ${session.id} (${session.guest} on ${session.project_name}). Its link no longer works.`);
             }
             else {
                 await deleteSession(config, store, session.id);
-                console.log(`Deleted ${session.id} (${session.tester} on ${session.project_name}) and its screenshots.`);
+                console.log(`Deleted ${session.id} (${session.guest} on ${session.project_name}) and its screenshots.`);
+                console.log(`${session.agent === "codex" ? "Codex" : "Claude Code"} keeps its own log of the conversation (in ${session.agent === "codex" ? "~/.codex/sessions" : "~/.claude/projects"}); delete it there too if you want it gone everywhere.`);
             }
             return;
         }
@@ -211,6 +220,13 @@ async function main() {
         }
         case "install":
             return install(config);
+        case "uninstall":
+            return uninstall(config);
+        case "version":
+        case "--version":
+        case "-v":
+            console.log(VERSION);
+            return;
         case undefined:
         case "help":
         case "--help":
@@ -221,7 +237,7 @@ async function main() {
             fail(`Unknown command: ${command}\n\n${HELP}`);
     }
 }
-function install(config) {
+async function install(config) {
     const launch = [process.execPath, "--no-warnings", CLI_PATH, "mcp"];
     const env = cleanEnv();
     const run = (bin, args) => {
@@ -247,8 +263,34 @@ function install(config) {
     }
     else
         console.log("Codex: not found, skipped.");
+    // The server holds your links; it should come back after a restart.
+    await stopServer(config);
+    console.log(`Server: ${enableAutostart(CLI_PATH)}`);
+    if (!(await ensureServer(config)))
+        console.log(`The server didn't come up. See ${paths.log}`);
     console.log(`\nStart a new Claude or Codex session in any project and ask it to make a parley for someone.`);
 }
+// Undoes `parley install`. Your conversations stay in each project's .parley
+// folder, and settings and login in ~/.parley.
+async function uninstall(config) {
+    const run = (bin, args) => {
+        try {
+            execFileSync(bin, args, { env: cleanEnv(), stdio: "pipe" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (config.claude.bin.startsWith("/") && run(config.claude.bin, ["mcp", "remove", "--scope", "user", "parley"]))
+        console.log("Claude Code: removed the parley MCP server.");
+    if (config.codex.bin.startsWith("/") && run(config.codex.bin, ["mcp", "remove", "parley"]))
+        console.log("Codex: removed the parley MCP server.");
+    console.log(disableAutostart() ?? "Wasn't set to start at login.");
+    if (await stopServer(config))
+        console.log("Stopped the server.");
+    console.log(`\nYour conversations are still in each project's .parley folder, and settings and login in ${paths.home}.`);
+}
 async function printRelay(config) {
     const creds = readCredentials(config);
     if (!creds)
@@ -269,4 +311,9 @@ function fail(message) {
     console.error(message);
     process.exit(1);
 }
-main().catch((error) => fail(String(error?.stack ?? error)));
+// Mistakes in how parley was called get a sentence, not a stack trace.
+main().catch((error) => {
+    if (typeof error?.code === "string" && error.code.startsWith("ERR_PARSE_ARGS"))
+        fail(`${error.message}\nRun parley on its own for help.`);
+    fail(process.env.PARLEY_DEBUG ? String(error?.stack ?? error) : String(error?.message ?? error));
+});

package/dist/config.js

@@ -1,17 +1,53 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, accessSync, constants } from "node:fs";
 import { homedir } from "node:os";
-import { join, delimiter } from "node:path";
+import { join, delimiter, basename } from "node:path";
 export const HOME = process.env.PARLEY_HOME ?? join(homedir(), ".parley");
+// Settings, your parley.im login and the server's state. Conversations live
+// in each project's own .parley folder (see db.ts); projects.json lists them.
 export const paths = {
     home: HOME,
     config: join(HOME, "config.json"),
-    db: join(HOME, "parley.db"),
+    projects: join(HOME, "projects.json"),
     state: join(HOME, "server.json"),
     log: join(HOME, "server.log"),
-    uploads: join(HOME, "uploads"),
     // Your computer's link to a parley.im account, from `parley login`.
     credentials: join(HOME, "credentials.json"),
 };
+export const BLOCKED_BY_DEFAULT = [
+    // Environment files and other places secrets usually live.
+    "**/.env",
+    "**/.env.*",
+    "**/.dev.vars",
+    "**/secrets/**",
+    "**/secrets.json",
+    "**/secrets.yml",
+    "**/secrets.yaml",
+    "**/credentials.json",
+    "**/*.tfstate",
+    "**/*.tfvars",
+    // Keys and certificates.
+    "**/*.pem",
+    "**/*.key",
+    "**/*.p12",
+    "**/*.pfx",
+    "**/*.jks",
+    "**/*.keystore",
+    "**/id_rsa*",
+    "**/id_dsa*",
+    "**/id_ecdsa*",
+    "**/id_ed25519*",
+    // Tool logins.
+    "**/.ssh/**",
+    "**/.aws/**",
+    "**/.gnupg/**",
+    "**/.kube/**",
+    "**/.docker/**",
+    "**/.npmrc",
+    "**/.pypirc",
+    "**/.netrc",
+    "**/.git-credentials",
+    "**/.git/config",
+];
 const defaults = {
     relayUrl: "https://parley.im",
     port: 4747,
@@ -20,9 +56,10 @@ const defaults = {
     replyLimit: 100,
     claude: { bin: "claude", model: null, effort: null },
     codex: { bin: "codex", model: null, effort: null },
+    interviewer: { readConversations: false, blocked: BLOCKED_BY_DEFAULT, allowHomeFolder: false },
 };
 export function ensureHome() {
-    mkdirSync(paths.uploads, { recursive: true });
+    mkdirSync(paths.home, { recursive: true });
 }
 export function loadConfig() {
     ensureHome();
@@ -39,18 +76,20 @@ export function loadConfig() {
         replyLimit: pick("replyLimit"),
         claude: { ...defaults.claude, ...stored.claude },
         codex: { ...defaults.codex, ...stored.codex },
+        interviewer: { ...defaults.interviewer, ...stored.interviewer },
     };
     // The server is often started from inside an MCP server with a thin PATH,
-    // so binaries are pinned to absolute paths the first time they are found.
-    let changed = !existsSync(paths.config) || Object.keys(stored).some((key) => !(key in defaults));
+    // so binaries are pinned to absolute paths the first time they are found,
+    // and found again if they move (say, from npm to a native installer).
+    let changed = !existsSync(paths.config) || Object.keys(stored).some((key) => !(key in defaults)) || !stored.interviewer;
     for (const [get, set] of [
         [() => config.claude.bin, (v) => (config.claude.bin = v)],
         [() => config.codex.bin, (v) => (config.codex.bin = v)],
     ]) {
         const current = get();
-        if (current.startsWith("/"))
+        if (current.startsWith("/") && existsSync(current))
             continue;
-        const found = findBin(current);
+        const found = findBin(basename(current));
         if (found) {
             set(found);
             changed = true;
@@ -83,13 +122,15 @@ export function findBin(name) {
     }
     return null;
 }
-// Agents run as you, on your own subscription. Anything inherited from a
-// host session (Claude Code's own env, API keys, proxies) is dropped so the
-// CLIs fall back to your normal login.
+// Agents run as you, on your own subscription. What a host session (Claude
+// Code itself, an MCP client) put in the environment is dropped, API keys
+// included, so the CLIs fall back to your normal login. Settings that choose
+// where that login lives (a config folder, Bedrock, Vertex, a proxy) stay.
+const KEEP = new Set(["CLAUDE_CONFIG_DIR", "CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX", "ANTHROPIC_BASE_URL", "ANTHROPIC_VERTEX_PROJECT_ID"]);
 export function cleanEnv() {
     const env = {};
     for (const [key, value] of Object.entries(process.env)) {
-        if (/^(CLAUDE|ANTHROPIC_|MCP_)/.test(key))
+        if (/^(CLAUDE|ANTHROPIC_|MCP_)/.test(key) && !KEEP.has(key))
             continue;
         env[key] = value;
     }

package/dist/control.js

@@ -1,28 +1,34 @@
-import { existsSync, statSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute } from "node:path";
 import { isServerUp } from "./state.js";
 import { readCredentials, relay as registry } from "./account.js";
 import { ensureServer } from "./daemon.js";
+import { agentProblem, checkProjectFolder, defaultAgent } from "./access.js";
 // The one way sessions get made, from the CLI, MCP tools or your control panel.
 export function createSession(store, config, input) {
     if (!isAbsolute(input.projectDir))
         throw new Error(`Use the full path of the project folder, not ${input.projectDir}.`);
-    const projectDir = resolve(input.projectDir);
-    if (!existsSync(projectDir) || !statSync(projectDir).isDirectory())
-        throw new Error(`Not a folder: ${projectDir}`);
-    const tester = input.tester.trim();
+    if (!existsSync(input.projectDir) || !statSync(input.projectDir).isDirectory())
+        throw new Error(`Not a folder: ${input.projectDir}`);
+    const projectDir = realpathSync(input.projectDir);
+    checkProjectFolder(projectDir, config);
+    const guest = input.guest.trim();
     const brief = input.brief.trim();
-    if (!tester)
+    if (!guest)
         throw new Error("Say who the session is for.");
     if (!brief)
         throw new Error("Write a brief for the interviewer.");
     const replyLimit = input.replyLimit ?? config.replyLimit;
     if (!Number.isInteger(replyLimit) || replyLimit < 1)
         throw new Error("The reply limit has to be a whole number above zero.");
-    return store.createSession({ ...input, projectDir, tester, brief, replyLimit });
+    const agent = input.agent ?? defaultAgent(config);
+    const problem = agentProblem(config, agent);
+    if (problem)
+        throw new Error(problem);
+    return store.createSession({ ...input, projectDir, guest, brief, replyLimit, agent });
 }
 // Changes go through the server when it's running, so a reply in progress
-// stops, any open tester page updates at once, and parley.im hears about it.
+// stops, any open guest page updates at once, and parley.im hears about it.
 async function viaServer(config, path, body) {
     const res = await fetch(`http://localhost:${config.dashboardPort}${path}`, {
         method: "POST",
@@ -39,7 +45,7 @@ async function viaServer(config, path, body) {
 export async function startSession(store, config, input) {
     if (await ensureServer(config)) {
         const made = await viaServer(config, "/api/sessions", input);
-        return { session: store.session(made.id), shared: made.shared, serverUp: true };
+        return { session: made.session ?? store.session(made.id), shared: made.shared, serverUp: true };
     }
     const session = createSession(store, config, input);
     return { session, shared: false, serverUp: false };

package/dist/daemon.js

@@ -1,15 +1,30 @@
 import { spawn } from "node:child_process";
-import { openSync } from "node:fs";
+import { openSync, rmSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { paths, cleanEnv } from "./config.js";
-import { readState, isServerUp } from "./state.js";
+import { readState, serverHealth } from "./state.js";
+import { VERSION, compareVersions } from "./version.js";
 // cli.ts in a checkout, cli.js once built for npm.
 const CLI = join(dirname(fileURLToPath(import.meta.url)), import.meta.url.endsWith(".ts") ? "cli.ts" : "cli.js");
 // Starts the server in the background if it isn't running, and waits until
-// it answers. It holds this computer's connection to parley.im.
+// it answers. It holds this computer's connection to parley.im. A server from
+// an older parley is replaced; one newer than this process means this process
+// is the stale one (an MCP server started before an update).
 export async function ensureServer(config, waitMs = 20_000) {
-    if (!(await isServerUp(config))) {
+    const running = await serverHealth(config);
+    if (running?.version && running.version !== VERSION) {
+        if (compareVersions(running.version, VERSION) > 0) {
+            throw new Error(`parley was updated to ${running.version}, but this process is still ${VERSION}. Restart this Claude Code or Codex session (or the parley command) to use the new version.`);
+        }
+        await stopServer(config);
+        await waitUntilDown(config);
+    }
+    else if (running && !running.version) {
+        await stopServer(config);
+        await waitUntilDown(config);
+    }
+    if (!(await serverHealth(config))) {
         const log = openSync(paths.log, "a");
         const child = spawn(process.execPath, ["--no-warnings", CLI, "serve"], {
             detached: true,
@@ -22,18 +37,27 @@ export async function ensureServer(config, waitMs = 20_000) {
     const deadline = Date.now() + waitMs;
     while (Date.now() < deadline) {
         const state = readState();
-        if (state && (await isServerUp(config)))
+        if (state && (await serverHealth(config)))
             return state;
         await new Promise((r) => setTimeout(r, 400));
     }
-    return (await isServerUp(config)) ? readState() : null;
+    return (await serverHealth(config)) ? readState() : null;
 }
-export async function stopServer() {
-    const state = readState();
-    if (!state)
+async function waitUntilDown(config, waitMs = 10_000) {
+    const deadline = Date.now() + waitMs;
+    while (Date.now() < deadline && (await serverHealth(config)))
+        await new Promise((r) => setTimeout(r, 200));
+}
+// Stops the server, but only a process that answers as parley's server: the
+// pid in server.json may be stale and belong to something else by now.
+export async function stopServer(config) {
+    const running = await serverHealth(config);
+    if (!running) {
+        rmSync(paths.state, { force: true });
         return false;
+    }
     try {
-        process.kill(state.pid, "SIGTERM");
+        process.kill(running.pid, "SIGTERM");
         return true;
     }
     catch {