pinomad 0.3.0 → 0.5.0

package/dist/chunk-ebfaf3k2.js

@@ -0,0 +1,190 @@
+import {
+  fromBase64Url,
+  generateKeyPair,
+  keyPairFromPrivate,
+  toBase64Url
+} from "./chunk-kmbh44dt.js";
+
+// apps/host/src/devices.ts
+import { link, readFile, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { defineDoc } from "@earendil-works/pi-durable";
+var DevicesDoc = defineDoc({
+  kind: "pinomad.devices",
+  version: 1,
+  scope: "session",
+  initial: () => ({ devices: [] })
+});
+async function ensureDevices(harness, context) {
+  await harness.commit(async (tx) => void await tx.doc(DevicesDoc), context);
+}
+var RevocationsDoc = defineDoc({
+  kind: "pinomad.revocations",
+  version: 1,
+  scope: "session",
+  initial: () => ({ revoked: [] })
+});
+async function admitDevice(harness, input, context) {
+  return await harness.commit(async (tx) => {
+    const devices = await tx.doc(DevicesDoc);
+    if (devices.devices.some((entry2) => entry2.publicKey === input.publicKey)) {
+      return { outcome: "registered" };
+    }
+    if (input.pair === undefined)
+      return { outcome: "refused" };
+    const offer = input.offers.consume(input.pair.secret);
+    if (offer === undefined)
+      return { outcome: "refused" };
+    const revocations = await tx.doc(RevocationsDoc);
+    if (offer.source === "account") {
+      const binding = await input.serverBinding();
+      if (revocations.revoked.includes(input.publicKey) || binding === undefined || offer.binding !== binding || !input.acceptAccountDevices()) {
+        return { outcome: "refused" };
+      }
+    }
+    const name = input.pair.name.trim().slice(0, 64) || "Unknown device";
+    const entry = { publicKey: input.publicKey, name, pairedAt: Date.now(), source: offer.source };
+    devices.devices.push(entry);
+    if (revocations.revoked.includes(input.publicKey)) {
+      revocations.revoked = revocations.revoked.filter((key) => key !== input.publicKey);
+    }
+    return { outcome: "admitted", entry };
+  }, context);
+}
+async function loadHostKey(dataDir) {
+  const path = join(dataDir, "host-key");
+  try {
+    const text = (await readFile(path, "utf8")).trim();
+    return keyPairFromPrivate(fromBase64Url(text));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    const pair = generateKeyPair();
+    if (!await createKeyFile(path, toBase64Url(pair.privateKey)))
+      return loadHostKey(dataDir);
+    return pair;
+  }
+}
+async function loadRelayKey(dataDir) {
+  const path = join(dataDir, "relay-key");
+  try {
+    const secretKey = fromBase64Url((await readFile(path, "utf8")).trim());
+    if (secretKey.length !== 32)
+      throw new Error(`bad relay key in ${path}`);
+    return { secretKey, publicKey: ed25519.getPublicKey(secretKey) };
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    const { secretKey, publicKey } = ed25519.keygen();
+    if (!await createKeyFile(path, toBase64Url(secretKey)))
+      return loadRelayKey(dataDir);
+    return { secretKey, publicKey };
+  }
+}
+async function createKeyFile(path, key) {
+  const tmp = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+  try {
+    await writeFile(tmp, `${key}
+`, { flag: "wx", mode: 384 });
+    await link(tmp, path);
+    return true;
+  } catch (race) {
+    if (race.code !== "EEXIST")
+      throw race;
+    return false;
+  } finally {
+    await unlink(tmp).catch(() => {});
+  }
+}
+function pairingOffers(ttlMs = 5 * 60 * 1000) {
+  const live = new Map;
+  const prune = () => {
+    const now = Date.now();
+    for (const [secret, offer] of live)
+      if (offer.expiresAt <= now)
+        live.delete(secret);
+  };
+  const mint = (offer) => {
+    prune();
+    const secret = toBase64Url(randomBytes(16));
+    const expiresAt = Date.now() + ttlMs;
+    live.set(secret, { expiresAt, ...offer });
+    return { secret, expiresAt };
+  };
+  return {
+    create: (source) => mint({ source }),
+    createAccount: (binding) => mint({ source: "account", binding }),
+    consume(secret) {
+      prune();
+      const candidate = Buffer.from(secret);
+      for (const [key, offer] of live) {
+        const offerBytes = Buffer.from(key);
+        if (offerBytes.length !== candidate.length)
+          continue;
+        if (timingSafeEqual(offerBytes, candidate)) {
+          live.delete(key);
+          return offer;
+        }
+      }
+      return;
+    },
+    revokeAccount() {
+      for (const [key, offer] of live)
+        if (offer.source === "account")
+          live.delete(key);
+    }
+  };
+}
+
+// apps/host/src/server-config.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { readFile as readFile2, rename, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var SERVER_CONFIG_FILE = "server.json";
+var normalizeOrigin = (origin) => origin.replace(/\/+$/, "");
+async function readServerConfig(dataDir) {
+  let text;
+  try {
+    text = await readFile2(join2(dataDir, SERVER_CONFIG_FILE), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(`${join2(dataDir, SERVER_CONFIG_FILE)} is not valid JSON — delete it or run \`pinomad leave\``);
+  }
+  const origin = value?.origin;
+  if (typeof origin !== "string" || origin.trim() === "") {
+    throw new Error(`${join2(dataDir, SERVER_CONFIG_FILE)} is missing a string "origin"`);
+  }
+  const binding = value.binding;
+  return {
+    origin,
+    ...typeof binding === "string" && binding !== "" ? { binding } : {}
+  };
+}
+async function writeServerConfig(dataDir, config) {
+  const path = join2(dataDir, SERVER_CONFIG_FILE);
+  const tmp = `${path}.tmp-${process.pid}`;
+  await writeFile2(tmp, `${JSON.stringify({ origin: normalizeOrigin(config.origin), binding: randomBytes2(16).toString("base64url") })}
+`, { mode: 384 });
+  await rename(tmp, path);
+}
+var removeServerConfig = (dataDir) => rm(join2(dataDir, SERVER_CONFIG_FILE), { force: true });
+async function readServerBinding(dataDir) {
+  return (await readServerConfig(dataDir))?.binding;
+}
+function resolveRelayOrigin(flag, config) {
+  if (flag !== undefined && config !== undefined && normalizeOrigin(flag) !== normalizeOrigin(config.origin)) {
+    throw new Error(`--relay ${flag} disagrees with ${SERVER_CONFIG_FILE} (${config.origin}) — remove one`);
+  }
+  return flag ?? config?.origin;
+}
+
+export { DevicesDoc, ensureDevices, RevocationsDoc, admitDevice, loadHostKey, loadRelayKey, pairingOffers, normalizeOrigin, readServerConfig, writeServerConfig, removeServerConfig, readServerBinding, resolveRelayOrigin };

package/dist/chunk-f0v3sht0.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import {
+  assertSecureServerOrigin,
+  probeServerAccounts,
+  runServerOperation
+} from "./chunk-26d04z02.js";
+import {
+  loadHostKey,
+  loadRelayKey,
+  readServerConfig,
+  removeServerConfig
+} from "./chunk-ebfaf3k2.js";
+import {
+  relayHostId
+} from "./chunk-kmbh44dt.js";
+import {
+  argValue,
+  restartService,
+  serviceManager,
+  withoutRelayArgs
+} from "./chunk-aqj4wg33.js";
+import"./chunk-1d9sppj0.js";
+import"./chunk-m4q9wafw.js";
+import"./chunk-hsp12cjt.js";
+import {
+  DEFAULT_DATA_DIR
+} from "./chunk-cjfmfyjb.js";
+import"./chunk-df32avw6.js";
+
+// apps/host/src/cli/leave.ts
+import { stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+var message = (error) => error instanceof Error ? error.message : String(error);
+async function leaveServer(args, deps) {
+  const dataDir = resolve(args.dataDir);
+  const config = await readServerConfig(dataDir);
+  if (config === undefined)
+    throw new Error(`not joined — no server.json in ${dataDir}`);
+  const origin = config.origin;
+  const warnings = [];
+  const notes = [];
+  let hostId;
+  assertSecureServerOrigin(origin);
+  if (await stat(join(dataDir, "relay-key")).then(() => true, () => false)) {
+    const signingKey = await loadRelayKey(dataDir);
+    const hostKey = await loadHostKey(dataDir);
+    hostId = relayHostId(signingKey.publicKey);
+    const probe = await probeServerAccounts(origin, deps?.fetch);
+    if (probe === "unreachable") {
+      warnings.push(`cannot reach ${origin} — the server-side binding was not removed`);
+    } else if (probe === "enabled") {
+      try {
+        const reply = await runServerOperation({
+          origin,
+          signingKey,
+          noisePublicKey: hostKey.publicKey,
+          op: "leave"
+        });
+        if (reply.t === "refused" && reply.reason !== "not_joined") {
+          warnings.push(`the server refused the leave: ${reply.reason}`);
+        } else if (reply.t === "refused") {
+          notes.push("the server had no binding for this host");
+        }
+      } catch (error) {
+        warnings.push(`the server could not be asked to unbind (${message(error)}) — its record of this host may remain`);
+      }
+    } else {
+      notes.push("the server runs no accounts — nothing was bound");
+    }
+  } else {
+    warnings.push("no relay key on disk — the server-side binding, if any, was not removed");
+  }
+  await removeServerConfig(dataDir);
+  const manager = deps?.manager ?? serviceManager();
+  try {
+    const installed = await manager.state().then((state) => state.installed, () => false);
+    const previous = installed ? await manager.read() : undefined;
+    if (!installed) {
+      notes.push("no service installed — restart any running host so it stops dialing the server");
+    } else if (previous !== undefined && resolve(previous.dataDir) !== dataDir) {
+      notes.push(`the installed service uses ${previous.dataDir}, not ${dataDir} — left untouched`);
+    } else {
+      const stripped = previous === undefined ? undefined : { ...previous, hostArgs: withoutRelayArgs(previous.hostArgs) };
+      const rewriting = stripped !== undefined && stripped.hostArgs.length !== previous.hostArgs.length;
+      const port = argValue(previous?.hostArgs ?? [], "--port");
+      const code = await restartService({
+        force: false,
+        argv: ["--data-dir", dataDir, ...port === undefined ? [] : ["--url", `ws://127.0.0.1:${port}`]],
+        manager,
+        ...rewriting ? {
+          restart: async () => {
+            await manager.install(stripped);
+          }
+        } : {}
+      });
+      if (code !== 0)
+        warnings.push("the service restart did not finish — check `service status`");
+    }
+  } catch (error) {
+    warnings.push(`could not update the service definition: ${message(error)} — remove --relay from it and restart manually`);
+  }
+  return {
+    origin,
+    ...hostId === undefined ? {} : { hostId },
+    warnings,
+    notes
+  };
+}
+async function main(argv) {
+  const { values } = parseArgs({
+    args: [...argv],
+    options: { "data-dir": { type: "string" } }
+  });
+  try {
+    const outcome = await leaveServer({ dataDir: values["data-dir"] ?? DEFAULT_DATA_DIR });
+    console.log(`left ${outcome.origin}`);
+    if (outcome.hostId !== undefined)
+      console.log(`host id: ${outcome.hostId}`);
+    for (const note of outcome.notes)
+      console.log(`note: ${note}`);
+    for (const warning of outcome.warnings)
+      console.error(`warning: ${warning}`);
+    if (outcome.warnings.length > 0)
+      process.exitCode = 1;
+  } catch (error) {
+    console.error(message(error));
+    process.exitCode = 1;
+  }
+}
+if (false)
+  ;
+export {
+  main,
+  leaveServer
+};

package/dist/{chunk-3qn8gbjb.js → chunk-gqr7ahv4.js}

@@ -1,6 +1,6 @@
 import {
   packagedVersion
-} from "./chunk-3tf23vjq.js";
+} from "./chunk-1d9sppj0.js";
 import {
   hostAddress
 } from "./chunk-cjfmfyjb.js";

package/dist/{chunk-c155p0t0.js → chunk-hsp12cjt.js}

@@ -3,7 +3,8 @@ var HOST_SETTING_KEY_SET = {
   defaultModel: true,
   defaultThinkingLevel: true,
   steeringMode: true,
-  followUpMode: true
+  followUpMode: true,
+  acceptAccountDevices: true
 };
 var HOST_SETTING_KEYS = Object.keys(HOST_SETTING_KEY_SET);
 var THINKING_LEVEL_KEYS = { off: true, minimal: true, low: true, medium: true, high: true, xhigh: true, max: true };
@@ -21,7 +22,7 @@ var conversationStream = (id) => `conversation:${id}`;
 var docStream = (kind, id) => `doc:${kind}:${id}`;
 var UNAUTHORIZED_CLOSE_CODE = 4401;
 var INVALID_FRAME_CLOSE_CODE = 4400;
-var PROTOCOL = { major: 5, minor: 6 };
+var PROTOCOL = { major: 5, minor: 10 };
 var CALL_SINCE = {
   logout: 1,
   updateSettings: 2,
@@ -29,12 +30,14 @@ var CALL_SINCE = {
   renameConversation: 4,
   createAgent: 6,
   updateAgent: 6,
-  deleteAgent: 6
+  deleteAgent: 6,
+  setPushToken: 7,
+  listFiles: 10
 };
 function hostSupportsCall(hostMinor, method) {
   return hostMinor >= (CALL_SINCE[method] ?? 0);
 }
-var FEATURE_SINCE = { images: 5 };
+var FEATURE_SINCE = { images: 5, acceptAccountDevices: 8, apnsPush: 9, agentConversations: 10 };
 function hostSupportsFeature(hostMinor, feature) {
   return hostMinor >= FEATURE_SINCE[feature];
 }
@@ -89,13 +92,16 @@ var CALL_METHODS = [
   "updateSettings",
   "createAgent",
   "updateAgent",
-  "deleteAgent"
+  "deleteAgent",
+  "setPushToken",
+  "listFiles"
 ];
 var SETTING_VALIDATORS = {
   defaultModel: (value) => value === null || record(value) && nonempty(value.provider) && nonempty(value.modelId),
   defaultThinkingLevel: (value) => value === null || isThinkingLevel(value),
   steeringMode: (value) => value === null || isQueueMode(value),
-  followUpMode: (value) => value === null || isQueueMode(value)
+  followUpMode: (value) => value === null || isQueueMode(value),
+  acceptAccountDevices: (value) => value === null || typeof value === "boolean"
 };
 function validCallArgs(method, args) {
   const conversationId = () => typeof args.conversationId === "number" && Number.isSafeInteger(args.conversationId) && args.conversationId >= 1;
@@ -124,7 +130,9 @@ function validCallArgs(method, args) {
     case "listFolders":
       return args.path === undefined || nonempty(args.path);
     case "createConversation":
-      return record(args.home) && (args.home.kind === "chat" || args.home.kind === "project" && nonempty(args.home.path)) && typeof args.text === "string" && (nonempty(args.text) || Array.isArray(args.images) && args.images.length > 0) && nonempty(args.requestId) && images() && (args.checkout === undefined || args.checkout === "worktree" || args.checkout === "project") && (args.model === undefined || record(args.model) && nonempty(args.model.provider) && nonempty(args.model.modelId)) && (args.thinkingLevel === undefined || nonempty(args.thinkingLevel));
+      return record(args.home) && (args.home.kind === "chat" || args.home.kind === "project" && nonempty(args.home.path)) && typeof args.text === "string" && (nonempty(args.text) || Array.isArray(args.images) && args.images.length > 0) && nonempty(args.requestId) && images() && (args.checkout === undefined || args.checkout === "worktree" || args.checkout === "project") && (args.model === undefined || record(args.model) && nonempty(args.model.provider) && nonempty(args.model.modelId)) && (args.thinkingLevel === undefined || nonempty(args.thinkingLevel)) && (args.agent === undefined || nonempty(args.agent));
+    case "listFiles":
+      return typeof args.query === "string" && record(args.scope) && (args.scope.kind === "conversation" && typeof args.scope.conversationId === "number" && Number.isSafeInteger(args.scope.conversationId) && args.scope.conversationId >= 1 || args.scope.kind === "project" && nonempty(args.scope.path) && (args.scope.checkout === "worktree" || args.scope.checkout === "project"));
     case "archive":
       return conversationId() && typeof args.archived === "boolean";
     case "renameConversation":
@@ -140,6 +148,8 @@ function validCallArgs(method, args) {
       return role();
     case "deleteAgent":
       return typeof args.name === "string";
+    case "setPushToken":
+      return args.token === null || typeof args.token === "string" || record(args.token) && typeof args.token.apns === "string" && (args.token.environment === "production" || args.token.environment === "development");
     case "updateSettings":
       return record(args.patch) && Object.keys(args.patch).every((key) => HOST_SETTING_KEYS.includes(key)) && Object.entries(args.patch).every(([key, value]) => SETTING_VALIDATORS[key]?.(value) === true);
   }
@@ -151,4 +161,97 @@ function nonempty(value) {
   return typeof value === "string" && value.length > 0;
 }
 
-export { HOST_SETTING_KEYS, THINKING_LEVELS, isThinkingLevel, isQueueMode, HOST_STREAM_NAMES, hostStreams, conversationStream, docStream, UNAUTHORIZED_CLOSE_CODE, INVALID_FRAME_CLOSE_CODE, PROTOCOL, hostSupportsCall, hostSupportsFeature, parseClientFrame };
+// packages/protocol/src/organization.ts
+function organize(index, summaries) {
+  const summaryById = new Map(summaries.map((summary) => [summary.id, summary]));
+  const nodes = new Map;
+  const topLevel = new Map;
+  for (const entry of index.conversations) {
+    const home = entry.home;
+    if (home.kind === "project" && !index.projects.some((project) => project.path === home.path))
+      continue;
+    const summary = summaryById.get(entry.id);
+    if (summary === undefined)
+      continue;
+    topLevel.set(entry.id, entry);
+    nodes.set(entry.id, { summary, children: [] });
+  }
+  for (const summary of summaries) {
+    const chain = [summary];
+    let current = summary;
+    while (!topLevel.has(current.id)) {
+      const parent = current.parent === undefined ? undefined : summaryById.get(current.parent);
+      if (parent === undefined || chain.includes(parent))
+        break;
+      chain.push(parent);
+      current = parent;
+    }
+    if (!topLevel.has(current.id))
+      continue;
+    for (let i = chain.length - 1;i >= 0; i--) {
+      const member = chain[i];
+      if (!nodes.has(member.id))
+        nodes.set(member.id, { summary: member, children: [] });
+      if (i < chain.length - 1) {
+        const parent = nodes.get(chain[i + 1].id);
+        const child = nodes.get(member.id);
+        if (!parent.children.includes(child))
+          parent.children.push(child);
+      }
+    }
+  }
+  const byIdAscending = (a, b) => a.summary.id - b.summary.id;
+  const nodeList = (entry) => sortChildren(nodes.get(entry.id));
+  const sortChildren = (node) => ({
+    summary: node.summary,
+    children: [...node.children].sort(byIdAscending).map(sortChildren)
+  });
+  const sorted = [...topLevel.values()].sort((a, b) => b.createdAt - a.createdAt);
+  const entries = sorted.filter((entry) => entry.archived !== true);
+  return {
+    chats: entries.filter((entry) => entry.home.kind === "chat").map(nodeList),
+    projects: [...index.projects].sort((a, b) => b.addedAt - a.addedAt).map((project) => ({
+      project,
+      conversations: entries.filter((entry) => entry.home.kind === "project" && entry.home.path === project.path).map(nodeList)
+    })),
+    archived: sorted.filter((entry) => entry.archived === true).map((entry) => {
+      const home = entry.home;
+      const project = home.kind === "project" ? index.projects.find((each) => each.path === home.path) : undefined;
+      return { node: nodeList(entry), ...project === undefined ? {} : { project } };
+    })
+  };
+}
+function checkoutOf(index, summaries, id) {
+  const record2 = index.checkouts?.find((checkout) => checkout.conversationId === id);
+  if (record2 !== undefined)
+    return record2;
+  const summaryById = new Map(summaries.map((summary) => [summary.id, summary]));
+  const seen = new Set;
+  let current = summaryById.get(id);
+  while (current !== undefined && !seen.has(current.id)) {
+    seen.add(current.id);
+    const ancestor = index.checkouts?.find((checkout) => checkout.conversationId === current.id);
+    if (ancestor !== undefined)
+      return ancestor;
+    current = current.parent === undefined ? undefined : summaryById.get(current.parent);
+  }
+  return;
+}
+function homeOf(index, summaries, id) {
+  const entry = index.conversations.find((candidate) => candidate.id === id);
+  if (entry !== undefined)
+    return entry.home;
+  const summaryById = new Map(summaries.map((summary) => [summary.id, summary]));
+  const seen = new Set;
+  let current = summaryById.get(id);
+  while (current !== undefined && !seen.has(current.id)) {
+    seen.add(current.id);
+    const ancestor = index.conversations.find((candidate) => candidate.id === current.id);
+    if (ancestor !== undefined)
+      return ancestor.home;
+    current = current.parent === undefined ? undefined : summaryById.get(current.parent);
+  }
+  return;
+}
+
+export { HOST_SETTING_KEYS, THINKING_LEVELS, isThinkingLevel, isQueueMode, HOST_STREAM_NAMES, hostStreams, conversationStream, docStream, UNAUTHORIZED_CLOSE_CODE, INVALID_FRAME_CLOSE_CODE, PROTOCOL, hostSupportsCall, hostSupportsFeature, parseClientFrame, organize, checkoutOf, homeOf };