parley-chat 0.1.1 → 0.2.1

package/main.mjs

@@ -76,7 +76,7 @@ async function fileExists(path) {
 var init_files = () => {};
 
 // src/main.ts
-import { execFile } from "child_process";
+import { execFile, spawn as spawn2 } from "child_process";
 import { mkdir as mkdir3, readFile as readFile3, rm as rm3, stat as stat3, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
@@ -92,21 +92,20 @@ description: Ask a mutual contact's local agent a question through Parley, with
 
 Parley lets your human exchange one-off questions with a friend's local agent. The relay is ephemeral: it keeps accounts, contacts, unexpired invites, and only active requests. Every agent-written reply requires the owner's Discord approval before delivery.
 
-## Setup
+## Setup (in order; verify with \`parley doctor\` after each step)
 
-1. Install the CLI and authenticate: \`parley login\`.
-2. Create \`~/.parley/config.toml\` with a command that reads stdin and writes a draft to stdout:
+You can run this entire setup for your human. Steps 2 and 6 need them present (browser login, Discord taps); everything else is yours to do.
 
-\`\`\`toml
-command = "claude -p"
-context = """
-You are answering questions asked by my friends through Parley.
-Use only the local paths my human permits. Never reveal secrets or tokens.
-"""
-\`\`\`
+1. Install: \`npm install -g parley-chat\` (requires node >= 22; the background responder is macOS-only). If \`parley\` is missing afterwards, npm's global bin directory is not on PATH — \`npm bin -g\` shows where it is.
+2. \`parley login\` — opens Discord OAuth in the browser; your human completes it. This also installs the Parley Discord app on their account so approval DMs can reach them.
+3. \`parley init\` — scaffolds \`~/.parley/config.toml\` with a safe default handler (\`claude -p\`). Then tailor it WITH your human: \`command\` is any shell command that reads a prompt on stdin and writes the reply to stdout; \`context\` should say who asks, what paths/topics are fair game, and what is off-limits. Ask your human what they want to share before writing it.
+4. \`parley install\` — registers the always-on responder (launchd). \`parley listen\` is the foreground equivalent for testing.
+5. \`parley doctor\` — every line should read \`ok\`. Fix the first \`FAIL\` (each names its own fix) and re-run until clean. Do not continue until doctor passes.
+6. Connect a friend: \`parley invite\` prints a code + link for your human to send. The friend completes steps 1-5, runs \`parley join CODE\`, and the inviter taps **Connect** in the Discord DM. \`parley contacts\` then lists the friend on both sides.
 
-3. Start the responder with \`parley listen\`, or install the macOS launchd agent once with \`parley install\`.
-4. Add a friend: \`parley invite\`, send the six-character code, then have them run \`parley join CODE\`. Their redemption stays pending until you tap **Connect** in the Discord DM.
+## Troubleshooting
+
+\`parley doctor\` is the first move for any problem — it checks node version, relay reachability, credentials, token validity, config parsing, handler availability, the launchd agent, and responder connectivity, in dependency order. \`parley status\` is the short version; \`parley logs\` tails the responder log. An ask failing with "offline" means the RECIPIENT's responder is down — their doctor run, not yours.
 
 ## Commands
 
@@ -119,6 +118,8 @@ Use only the local paths my human permits. Never reveal secrets or tokens.
 - \`parley ask @NAME "question"\`: blocks for a one-off response. It fails immediately when the responder is offline.
 - \`parley listen\`: runs the local responder in the foreground.
 - \`parley install\` / \`parley uninstall\`: manages the macOS launchd responder.
+- \`parley init\`: scaffolds \`~/.parley/config.toml\` with a safe default (no-op if it exists).
+- \`parley doctor\`: full diagnostic — checks every setup dependency in order and names the fix for each failure.
 - \`parley status\`: reports local responder and configuration status.
 - \`parley logs\`: tails the launchd responder log.
 - \`parley skills --write\`: writes this document to \`.claude/skills/parley/SKILL.md\` in the current directory.
@@ -484,6 +485,118 @@ async function logs() {
 `));
   return 0;
 }
+var defaultConfig = `command = "claude -p"
+context = """
+You are answering questions asked by my friends through Parley.
+Answer helpfully from my machine's context, but follow these rules:
+- Read-only: do not modify files or run anything with side effects.
+- Never reveal secrets, tokens, credentials, or private messages.
+- If a question needs something private, say I should answer directly.
+"""
+`;
+async function init() {
+  const path = join3(parleyHome2(), "config.toml");
+  if (await fileExists2(path)) {
+    process.stdout.write(`config already exists at ${path}
+`);
+    return 0;
+  }
+  await mkdir3(parleyHome2(), { recursive: true, mode: 448 });
+  await writeFile3(path, defaultConfig, { mode: 384 });
+  process.stdout.write(`wrote ${path}
+edit the command and context to fit your setup, then run: parley install
+`);
+  return 0;
+}
+async function doctor() {
+  const checks = [];
+  const nodeVersion = process.versions.node;
+  checks.push(["node", `${nodeVersion} (need >= 22)`, Number(nodeVersion.split(".")[0]) >= 22]);
+  checks.push(["platform", process.platform, process.platform === "darwin"]);
+  checks.push(["relay url", relayUrl2(), true]);
+  const reachable = await fetch(relayUrl2()).then((response) => response.ok).catch(() => false);
+  checks.push(["relay reachable", reachable ? "yes" : "no \u2014 check network", reachable]);
+  const hasCredentials = await fileExists2(join3(parleyHome2(), "credentials.json"));
+  checks.push(["credentials", hasCredentials ? "present" : "missing \u2014 run: parley login", hasCredentials]);
+  if (hasCredentials) {
+    const account = await credentials2().catch(() => null);
+    const authed = account ? await apiJson("/v1/contacts").then(() => true).catch(() => false) : false;
+    checks.push(["logged in as", account?.account.username ?? "unreadable", account !== null]);
+    checks.push(["token valid", authed ? "yes" : "no \u2014 run: parley login", authed]);
+  }
+  const hasConfig = await fileExists2(join3(parleyHome2(), "config.toml"));
+  checks.push(["config", hasConfig ? join3(parleyHome2(), "config.toml") : "missing \u2014 run: parley init", hasConfig]);
+  if (hasConfig) {
+    const local = await config2().catch(() => null);
+    checks.push(["config parses", local ? `command: ${local.command}` : "no \u2014 invalid toml, run: parley init after moving it aside", local !== null]);
+    if (local) {
+      const handler = await new Promise((resolve) => {
+        const child = execFile("sh", ["-c", `command -v ${JSON.stringify(local.command.split(" ")[0] === "cd" ? local.command.split("&&").at(-1)?.trim().split(" ")[0] ?? "" : local.command.split(" ")[0])}`], (error) => resolve(error === null));
+        setTimeout(() => {
+          child.kill();
+          resolve(false);
+        }, 5000);
+      });
+      checks.push(["handler command found", handler ? "yes" : "no \u2014 the command in config.toml is not on PATH", handler]);
+      if (handler) {
+        process.stdout.write(`running a test draft through your handler (this is what answers your friends; may take a minute)\u2026
+`);
+        const probe = await new Promise((resolve) => {
+          const child = spawn2("sh", ["-c", local.command], { stdio: ["pipe", "pipe", "pipe"] });
+          const out = [];
+          const err = [];
+          child.stdout.on("data", (chunk) => out.push(chunk));
+          child.stderr.on("data", (chunk) => err.push(chunk));
+          const timer = setTimeout(() => {
+            child.kill();
+            resolve({ ok: false, detail: "timed out after 120s \u2014 the handler hung instead of answering" });
+          }, 120000);
+          child.on("close", (code) => {
+            clearTimeout(timer);
+            const text2 = Buffer.concat(out).toString("utf8").trim();
+            const errText = Buffer.concat(err).toString("utf8").trim().split(`
+`).at(-1) ?? "";
+            if (code !== 0)
+              resolve({ ok: false, detail: `exited ${code}${errText ? ` \u2014 ${errText}` : ""}` });
+            else if (text2.length === 0)
+              resolve({ ok: false, detail: "produced no output \u2014 a real ask would auto-deny" });
+            else
+              resolve({ ok: true, detail: `replied: ${text2.slice(0, 60)}${text2.length > 60 ? "\u2026" : ""}` });
+          });
+          child.stdin.write(`${local.context}
+
+Asker: parley doctor
+Question: reply with the single word "pong" and nothing else
+`);
+          child.stdin.end();
+        });
+        checks.push(["handler test draft", probe.detail, probe.ok]);
+      }
+    }
+  }
+  checks.push(["launchagent", await launchAgentState(), await launchAgentState() === "loaded"]);
+  const online = hasCredentials ? object(await apiJson("/v1/status").catch(() => null))?.online === true : false;
+  checks.push(["responder online", online ? "yes" : "no \u2014 run: parley install (or parley listen)", online]);
+  const logPath = join3(parleyHome2(), "logs/listen.log");
+  const recentLog = await readFile3(logPath, "utf8").then((value) => value.split(`
+`).filter((line) => line.length > 0).slice(-3)).catch(() => []);
+  let failures = 0;
+  for (const [name, detail, ok] of checks) {
+    if (!ok)
+      failures += 1;
+    process.stdout.write(`${ok ? "ok  " : "FAIL"}  ${name}: ${detail}
+`);
+  }
+  if (recentLog.length > 0)
+    process.stdout.write(`recent log:
+${recentLog.map((line) => `  ${line}`).join(`
+`)}
+`);
+  process.stdout.write(failures === 0 ? `all checks passed
+` : `${failures} check(s) failed \u2014 fix the first FAIL, top to bottom, then re-run parley doctor
+`);
+  return failures === 0 ? 0 : 1;
+}
 async function skills(write) {
   if (write) {
     const path = join3(process.cwd(), ".claude/skills/parley");
@@ -527,8 +640,12 @@ async function main() {
       return logs();
     case "skills":
       return skills(args[0] === "--write");
+    case "init":
+      return init();
+    case "doctor":
+      return doctor();
     default:
-      process.stderr.write(`usage: parley <login|logout|invite|join|contacts|remove|ask|listen|install|uninstall|status|logs|skills>
+      process.stderr.write(`usage: parley <login|logout|invite|join|contacts|remove|ask|listen|install|uninstall|init|doctor|status|logs|skills>
 `);
       return 1;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parley-chat",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Ask your friends' local agents questions, with every reply approved by its human in Discord.",
   "type": "module",
   "bin": {