parley-chat 0.1.0

package/README.md

@@ -0,0 +1,18 @@
+# parley
+
+Your friend's agent asks your agent a question. Your agent drafts an answer
+from your real local context. You approve it from a Discord DM before it
+sends. Nothing is stored after delivery.
+
+```sh
+npm install -g parley-chat   # or: npx parley-chat
+parley login                 # Discord sign-in
+parley skills                # full setup guide (written for your agent to read)
+```
+
+Connect with a friend: one side runs `parley invite`, the other runs
+`parley join <code>`, the inviter taps Connect in the bot DM. Then:
+
+```sh
+parley ask @friend "how is your dev setup wired?"
+```

package/main.mjs

@@ -0,0 +1,540 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/files.ts
+var exports_files = {};
+__export(exports_files, {
+  saveCredentials: () => saveCredentials,
+  saveConfig: () => saveConfig,
+  removeCredentials: () => removeCredentials,
+  relayUrl: () => relayUrl,
+  parleyHome: () => parleyHome,
+  fileExists: () => fileExists,
+  credentials: () => credentials,
+  config: () => config
+});
+import { chmod, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function parleyHome() {
+  return process.env.PARLEY_HOME ?? join(homedir(), ".parley");
+}
+function relayUrl() {
+  return process.env.PARLEY_RELAY ?? "https://parley-relay.rhys-669.workers.dev";
+}
+async function credentials() {
+  return JSON.parse(await readFile(join(parleyHome(), "credentials.json"), "utf8"));
+}
+async function saveCredentials(value) {
+  await mkdir(parleyHome(), { recursive: true, mode: 448 });
+  const path = join(parleyHome(), "credentials.json");
+  await writeFile(path, JSON.stringify(value, null, 2), { mode: 384 });
+  await chmod(path, 384);
+}
+async function removeCredentials() {
+  await rm(join(parleyHome(), "credentials.json"), { force: true });
+}
+async function config() {
+  const source = await readFile(join(parleyHome(), "config.toml"), "utf8");
+  const command = /^command\s*=\s*"([^"]+)"\s*$/m.exec(source)?.[1];
+  const context = /^context\s*=\s*"""\n([\s\S]*?)\n"""\s*$/m.exec(source)?.[1];
+  if (!command || context === undefined)
+    throw new Error("invalid ~/.parley/config.toml");
+  return { command, context };
+}
+async function saveConfig(value) {
+  await mkdir(parleyHome(), { recursive: true, mode: 448 });
+  await writeFile(join(parleyHome(), "config.toml"), `command = ${JSON.stringify(value.command)}
+context = """
+${value.context}
+"""
+`, { mode: 384 });
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_files = () => {};
+
+// src/main.ts
+import { execFile } 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";
+import { promisify } from "util";
+
+// ../shared/src/protocol.ts
+var skillDocument = `---
+name: parley
+description: Ask a mutual contact's local agent a question through Parley, with both inbound execution and outbound replies approved in Discord.
+---
+
+# Parley
+
+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
+
+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:
+
+\`\`\`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.
+"""
+\`\`\`
+
+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.
+
+## Commands
+
+- \`parley login\`: starts Discord OAuth with the \`identify\` scope and stores a local opaque relay token.
+- \`parley logout\`: deletes the local token.
+- \`parley invite\`: creates a single-use code that expires after 48 hours.
+- \`parley join CODE\`: redeems a friend's invite and waits for their approval.
+- \`parley contacts\`: lists mutual contacts and whether their responder is connected.
+- \`parley remove NAME\`: removes a mutual contact for both people.
+- \`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 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.
+
+## Approval flow
+
+When a friend asks, the owner first sees the asker identity and exact question in a Discord DM. **Run** permits the local command to receive a composed prompt containing the configured context, asker username, and question. **Deny** stops it. **Deny with reason** opens a Discord modal and forwards the human-written reason to the asker.
+
+After the command drafts stdout, the owner sees a second Discord DM. **Approve** delivers it; **Deny** or **Deny with reason** rejects it. Empty stdout or a nonzero command exit automatically denies with \`agent failed to draft\`.
+
+## Agent use
+
+Use a literal question and a mutual contact name:
+
+\`\`\`sh
+parley ask @dave "Where is the deployment checklist?"
+\`\`\`
+
+Do not assume a reply will be delivered. The recipient can deny, be offline, or let the request expire after ten minutes. Do not put secrets in questions. Parley is not a chat system: there are no threads, queues, groups, history, or automatic approval.
+`;
+
+// src/http.ts
+init_files();
+async function api(path, init = {}) {
+  const auth = await credentials();
+  return fetch(`${relayUrl()}${path}`, { ...init, headers: { authorization: `Bearer ${auth.token}`, "content-type": "application/json", ...init.headers } });
+}
+async function apiJson(path, init = {}) {
+  const response = await api(path, init);
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(body);
+  }
+  return response.json();
+}
+
+// src/files.ts
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, rm as rm2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+function parleyHome2() {
+  return process.env.PARLEY_HOME ?? join2(homedir2(), ".parley");
+}
+function relayUrl2() {
+  return process.env.PARLEY_RELAY ?? "https://parley-relay.rhys-669.workers.dev";
+}
+async function credentials2() {
+  return JSON.parse(await readFile2(join2(parleyHome2(), "credentials.json"), "utf8"));
+}
+async function saveCredentials2(value) {
+  await mkdir2(parleyHome2(), { recursive: true, mode: 448 });
+  const path = join2(parleyHome2(), "credentials.json");
+  await writeFile2(path, JSON.stringify(value, null, 2), { mode: 384 });
+  await chmod2(path, 384);
+}
+async function removeCredentials2() {
+  await rm2(join2(parleyHome2(), "credentials.json"), { force: true });
+}
+async function config2() {
+  const source = await readFile2(join2(parleyHome2(), "config.toml"), "utf8");
+  const command = /^command\s*=\s*"([^"]+)"\s*$/m.exec(source)?.[1];
+  const context = /^context\s*=\s*"""\n([\s\S]*?)\n"""\s*$/m.exec(source)?.[1];
+  if (!command || context === undefined)
+    throw new Error("invalid ~/.parley/config.toml");
+  return { command, context };
+}
+async function fileExists2(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/responder.ts
+import { spawn } from "node:child_process";
+
+// src/http.ts
+init_files();
+async function api2(path, init = {}) {
+  const auth = await credentials();
+  return fetch(`${relayUrl()}${path}`, { ...init, headers: { authorization: `Bearer ${auth.token}`, "content-type": "application/json", ...init.headers } });
+}
+
+// src/responder.ts
+init_files();
+function wsUrl(path) {
+  return `${relayUrl().replace(/^http/, "ws")}${path}`;
+}
+async function draft(requestId, asker, question) {
+  const local = await config();
+  const prompt = `${local.context}
+
+Asker: ${asker}
+Question: ${question}
+`;
+  const child = spawn("sh", ["-c", local.command], { stdio: ["pipe", "pipe", "ignore"] });
+  child.stdin.write(prompt);
+  child.stdin.end();
+  const chunks = [];
+  child.stdout.on("data", (chunk) => chunks.push(chunk));
+  const code = await new Promise((resolve) => child.on("close", (value) => resolve(value ?? 1)));
+  const output = Buffer.concat(chunks).toString("utf8").trim();
+  await api2(`/v1/asks/${requestId}/draft`, { method: "POST", body: JSON.stringify({ draft: code === 0 ? output : "" }) });
+}
+async function listen() {
+  const auth = await Promise.resolve().then(() => (init_files(), exports_files)).then((module) => module.credentials());
+  const socket = new WebSocket(wsUrl("/v1/responders/connect"), [`parley.${auth.token}`]);
+  await new Promise((resolve, reject) => {
+    socket.addEventListener("open", () => resolve(), { once: true });
+    socket.addEventListener("error", () => reject(new Error("responder connection failed")), { once: true });
+  });
+  process.stderr.write(`listening
+`);
+  const questions = new Map;
+  socket.addEventListener("message", (event) => {
+    const value = JSON.parse(String(event.data));
+    if (value.type === "question") {
+      questions.set(value.requestId, value);
+      process.stderr.write(`waiting for approval from ${value.asker.username}…
+`);
+    }
+    if (value.type === "run") {
+      const question = questions.get(value.requestId);
+      if (question)
+        draft(question.requestId, question.asker.username, question.question);
+    }
+  });
+  await new Promise((resolve) => socket.addEventListener("close", () => resolve(), { once: true }));
+  return 1;
+}
+
+// src/main.ts
+var execute = promisify(execFile);
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text(value) {
+  return typeof value === "string" ? value : null;
+}
+function wsUrl2(path) {
+  return `${relayUrl2().replace(/^http/, "ws")}${path}`;
+}
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function oneTimeCode() {
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  return Buffer.from(bytes).toString("base64url");
+}
+async function login(args) {
+  const mockId = args[0] ?? process.env.PARLEY_MOCK_ID;
+  const mockUsername = args[1] ?? process.env.PARLEY_MOCK_USERNAME;
+  if (mockId && mockUsername) {
+    const response = await fetch(`${relayUrl2()}/v1/mock/login`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: mockId, username: mockUsername, avatar: null }) });
+    const value = object(await response.json());
+    const token = value ? text(value.token) : null;
+    const account = value ? object(value.account) : null;
+    if (!token || !account)
+      throw new Error("mock login failed");
+    await saveCredentials2({ token, account: { id: text(account.id) ?? "", username: text(account.username) ?? "", avatar: account.avatar === null ? null : text(account.avatar) } });
+    process.stdout.write(`logged in as ${text(account.username)}
+`);
+    return 0;
+  }
+  const loginCode = oneTimeCode();
+  const url = `${relayUrl2()}/oauth/login?login_code=${encodeURIComponent(loginCode)}`;
+  const opener = process.platform === "darwin" ? "open" : process.platform === "linux" ? "xdg-open" : null;
+  if (opener)
+    await execute(opener, [url]).catch(() => {
+      return;
+    });
+  process.stderr.write(`complete Discord login in your browser
+`);
+  process.stdout.write(`${url}
+`);
+  for (let attempt = 0;attempt < 600; attempt += 1) {
+    const response = await fetch(`${relayUrl2()}/oauth/poll`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ loginCode }) });
+    const value = response.ok ? object(await response.json()) : null;
+    if (value?.status === "complete") {
+      const token = text(value.token);
+      const account = object(value.account);
+      const id = account ? text(account.id) : null;
+      const username = account ? text(account.username) : null;
+      const avatar = account?.avatar === null ? null : account ? text(account.avatar) : null;
+      if (!token || !id || !username)
+        throw new Error("invalid oauth login response");
+      await saveCredentials2({ token, account: { id, username, avatar } });
+      process.stdout.write(`logged in as ${username}
+`);
+      return 0;
+    }
+    if (!response.ok && response.status !== 404)
+      throw new Error("oauth login failed");
+    await sleep(1000);
+  }
+  throw new Error("login timed out");
+}
+async function invite() {
+  const value = object(await apiJson("/v1/invites", { method: "POST" }));
+  const code = value ? text(value.code) : null;
+  if (!code)
+    throw new Error("invalid invite response");
+  process.stdout.write(`${code}
+${relayUrl2().replace(/^http:\/\//, "https://")}/i/${code}
+`);
+  return 0;
+}
+async function redeemInvite(code) {
+  if (!code)
+    throw new Error("usage: parley join <code>");
+  await apiJson("/v1/join", { method: "POST", body: JSON.stringify({ code }) });
+  process.stdout.write(`pending
+`);
+  return 0;
+}
+async function contacts() {
+  const value = object(await apiJson("/v1/contacts"));
+  const entries = Array.isArray(value?.contacts) ? value.contacts : [];
+  for (const entry of entries) {
+    const contact = object(entry);
+    if (contact)
+      process.stdout.write(`${text(contact.username)} (${contact.online === true ? "online" : "offline"})
+`);
+  }
+  return 0;
+}
+async function remove(name) {
+  if (!name)
+    throw new Error("usage: parley remove <name>");
+  const value = object(await apiJson("/v1/contacts"));
+  const match = (Array.isArray(value?.contacts) ? value.contacts : []).map(object).find((contact) => contact && text(contact.username) === name);
+  if (!match || !text(match.id))
+    throw new Error("not a contact");
+  await apiJson("/v1/contacts/remove", { method: "POST", body: JSON.stringify({ contactId: text(match.id) }) });
+  process.stdout.write(`removed
+`);
+  return 0;
+}
+async function ask(rawName, question) {
+  if (!rawName || !question)
+    throw new Error("usage: parley ask @<name> <question>");
+  const name = rawName.replace(/^@/, "");
+  const contactValue = object(await apiJson("/v1/contacts"));
+  const recipient = (Array.isArray(contactValue?.contacts) ? contactValue.contacts : []).map(object).find((contact) => contact && text(contact.username) === name);
+  const recipientId = recipient ? text(recipient.id) : null;
+  if (!recipientId) {
+    process.stderr.write(`not a contact
+`);
+    return 2;
+  }
+  const start = await api("/v1/asks", { method: "POST", body: JSON.stringify({ recipientId, question }) });
+  const started = object(await start.json());
+  if (started?.status === "offline") {
+    process.stderr.write(`${name}'s agent is offline right now \u2014 try again later.
+`);
+    return 2;
+  }
+  const requestId = started ? text(started.requestId) : null;
+  if (!start.ok || !requestId)
+    throw new Error("ask failed");
+  process.stderr.write(`waiting for ${name}\u2026
+`);
+  const auth = await credentials2();
+  const socket = new WebSocket(wsUrl2(`/v1/asks/${requestId}/events?recipient=${encodeURIComponent(recipientId)}`), [`parley.${auth.token}`]);
+  return new Promise((resolve, reject) => {
+    socket.addEventListener("message", (event) => {
+      const frame = JSON.parse(String(event.data));
+      if (frame.type === "state")
+        process.stderr.write(frame.stage === "drafting" ? `${name}'s agent is drafting\u2026
+` : `waiting for approval\u2026
+`);
+      if (frame.type === "answer") {
+        process.stdout.write(`${frame.answer}
+`);
+        socket.close();
+        resolve(0);
+      }
+      if (frame.type === "declined") {
+        process.stdout.write(frame.reason ? `declined: ${frame.reason}
+` : `declined
+`);
+        socket.close();
+        resolve(2);
+      }
+      if (frame.type === "timeout") {
+        process.stdout.write(`timed out
+`);
+        socket.close();
+        resolve(2);
+      }
+    });
+    socket.addEventListener("error", () => reject(new Error("ask connection failed")), { once: true });
+  });
+}
+function plist(entry) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict><key>Label</key><string>sh.parley.listen</string><key>ProgramArguments</key><array><string>${entry}</string><string>listen</string></array><key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>StandardOutPath</key><string>${join3(parleyHome2(), "logs/listen.log")}</string><key>StandardErrorPath</key><string>${join3(parleyHome2(), "logs/listen.log")}</string></dict></plist>
+`;
+}
+async function install() {
+  if (process.platform !== "darwin") {
+    process.stderr.write(`not supported yet
+`);
+    return 1;
+  }
+  const path = join3(homedir3(), "Library/LaunchAgents/sh.parley.listen.plist");
+  await mkdir3(join3(parleyHome2(), "logs"), { recursive: true, mode: 448 });
+  await writeFile3(path, plist(process.argv[1] ?? "parley"), { mode: 384 });
+  await execute("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 501}`, path]);
+  process.stdout.write(`installed
+`);
+  return 0;
+}
+async function uninstall() {
+  if (process.platform !== "darwin") {
+    process.stderr.write(`not supported yet
+`);
+    return 1;
+  }
+  const path = join3(homedir3(), "Library/LaunchAgents/sh.parley.listen.plist");
+  await execute("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}`, path]).catch(() => {
+    return;
+  });
+  await rm3(path, { force: true });
+  process.stdout.write(`uninstalled
+`);
+  return 0;
+}
+async function status() {
+  const hasCredentials = await fileExists2(join3(parleyHome2(), "credentials.json"));
+  const local = await config2().catch(() => null);
+  const online = hasCredentials ? object(await apiJson("/v1/status").catch(() => null))?.online === true : false;
+  const logPath = join3(parleyHome2(), "logs/listen.log");
+  const lastActivity = await stat3(logPath).then((entry) => entry.mtime.toISOString()).catch(() => "never");
+  const launchAgent = await launchAgentState();
+  const summary = local ? `${local.command} (${local.context.split(`
+`).filter((line) => line.length > 0).length} context lines)` : "missing";
+  process.stdout.write(`launchagent: ${launchAgent}
+responder: ${online ? "online" : "offline"}
+last activity: ${lastActivity}
+credentials: ${hasCredentials ? "present" : "missing"}
+config: ${summary}
+`);
+  return hasCredentials && local ? 0 : 1;
+}
+async function launchAgentState() {
+  if (process.platform !== "darwin")
+    return "not supported yet";
+  const uid = process.getuid?.();
+  if (uid === undefined)
+    return "unknown";
+  const result = await execute("launchctl", ["print", `gui/${uid}/sh.parley.listen`]).then(() => "loaded").catch(() => "not loaded");
+  return result;
+}
+async function logs() {
+  const path = join3(parleyHome2(), "logs/listen.log");
+  process.stdout.write((await readFile3(path, "utf8").catch(() => `no logs
+`)).split(`
+`).slice(-100).join(`
+`));
+  return 0;
+}
+async function skills(write) {
+  if (write) {
+    const path = join3(process.cwd(), ".claude/skills/parley");
+    await mkdir3(path, { recursive: true });
+    await writeFile3(join3(path, "SKILL.md"), skillDocument);
+    process.stdout.write(`wrote .claude/skills/parley/SKILL.md
+`);
+  } else
+    process.stdout.write(skillDocument);
+  return 0;
+}
+async function main() {
+  const [command, ...args] = process.argv.slice(2);
+  switch (command) {
+    case "login":
+      return login(args);
+    case "logout":
+      await removeCredentials2();
+      process.stdout.write(`logged out
+`);
+      return 0;
+    case "invite":
+      return invite();
+    case "join":
+      return redeemInvite(args[0]);
+    case "contacts":
+      return contacts();
+    case "remove":
+      return remove(args[0]);
+    case "ask":
+      return ask(args[0], args.slice(1).join(" "));
+    case "listen":
+      return listen();
+    case "install":
+      return install();
+    case "uninstall":
+      return uninstall();
+    case "status":
+      return status();
+    case "logs":
+      return logs();
+    case "skills":
+      return skills(args[0] === "--write");
+    default:
+      process.stderr.write(`usage: parley <login|logout|invite|join|contacts|remove|ask|listen|install|uninstall|status|logs|skills>
+`);
+      return 1;
+  }
+}
+main().then((code) => process.exit(code)).catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : "parley failed"}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "parley-chat",
+  "version": "0.1.0",
+  "description": "Ask your friends' local agents questions, with every reply approved by its human in Discord.",
+  "type": "module",
+  "bin": { "parley": "parley.mjs" },
+  "files": ["parley.mjs", "main.mjs"],
+  "engines": { "node": ">=22" },
+  "license": "MIT",
+  "repository": { "type": "git", "url": "https://github.com/rhyssullivan/parley" }
+}

package/parley.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./main.mjs";