@persistmemory/cli 0.1.1 → 0.1.2

package/dist/index.js

@@ -342,7 +342,7 @@ var SignalFired = class extends Error {
 };
 function untilAborted(work, signal) {
   work.catch(() => void 0);
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     if (signal.aborted) {
       reject(new SignalFired());
       return;
@@ -352,7 +352,7 @@ function untilAborted(work, signal) {
     work.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve6(value);
+        resolve7(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -362,14 +362,14 @@ function untilAborted(work, signal) {
   });
 }
 function defaultSleep(ms, signal) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     if (signal?.aborted) {
       reject(new AbortError());
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve6();
+      resolve7();
     }, ms);
     function onAbort() {
       clearTimeout(timer);
@@ -556,6 +556,58 @@ var Spaces = class {
   async create(params, options) {
     return this.#http.post("/api/v1/spaces", params, options);
   }
+  /**
+   * Deletes a Space. You must say what happens to what is in it.
+   *
+   * There is no default, here or in the API, and that is deliberate: "delete
+   * this Space" means the label to some people and everything inside it to
+   * others, and a client that guessed would destroy or keep somebody's
+   * material without being asked.
+   *
+   * `delete` never destroys a memory that is filed in another Space as well —
+   * that one is detached and left alone. `deleted` and `kept` come back so you
+   * can say what actually happened.
+   */
+  async delete(id, params, options) {
+    return this.#http.delete(
+      `/api/v1/spaces/${encodeURIComponent(id)}`,
+      params,
+      options
+    );
+  }
+  /**
+   * Merges Spaces into a NEW one, leaving every source exactly as it was.
+   *
+   * Additive, not destructive: a memory ends up in the sources AND the result,
+   * every existing search over a source returns what it did before, and
+   * undoing it is deleting the Space this returns. A memory in two sources is
+   * filed once.
+   */
+  async merge(params, options) {
+    return this.#http.post(
+      "/api/v1/spaces/merge",
+      params,
+      options
+    );
+  }
+  /**
+   * The Space this account files into when a capture names none.
+   *
+   * `{}` — an object with no `space` — means there is no default, which is the
+   * normal state rather than a gap. It is also what comes back after the Space
+   * somebody chose has been deleted.
+   */
+  async getDefault(options) {
+    return this.#http.get("/api/v1/spaces/default", void 0, options);
+  }
+  /** `null` clears it. Not the same as omitting it, which is why the type says so. */
+  async setDefault(spaceId, options) {
+    return this.#http.patch(
+      "/api/v1/spaces/default",
+      { spaceId },
+      options
+    );
+  }
   /** Renaming, retention, and archiving - `archived` is a field, not a verb. */
   async update(id, params, options) {
     return this.#http.patch(`/api/v1/spaces/${encodeURIComponent(id)}`, params, options);
@@ -918,6 +970,42 @@ var Health = class {
     return this.#http.get("/health/ready", void 0, options);
   }
 };
+var Agent = class {
+  #http;
+  constructor(http) {
+    this.#http = http;
+  }
+  /** The row, including whether it finished and how large the result is. */
+  async request(id, options) {
+    return this.#http.get(
+      `/api/v1/agent/request/${encodeURIComponent(id)}`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * A short-lived link to the bytes of a finished request.
+   *
+   * Returns the URL rather than the file, and that is a deliberate limit of
+   * this package rather than an oversight. The transport under every other
+   * method parses JSON, retries, and attaches the API key; none of those is
+   * right for a hundred-megabyte binary body, and building a second request
+   * path inside the SDK to serve one method is how a client ends up with two
+   * retry policies that differ only during an outage. Fetch the URL with
+   * whatever already streams in your runtime - it needs no credential, which
+   * is the whole reason it is signed.
+   *
+   * Treat the URL as the file. It is a bearer credential for exactly one
+   * object, it expires in minutes, and it should not be logged or stored.
+   */
+  async downloadLink(id, options) {
+    return this.#http.get(
+      `/api/v1/agent/request/${encodeURIComponent(id)}/download`,
+      void 0,
+      options
+    );
+  }
+};
 var PersistMemory = class {
   memories;
   search;
@@ -931,6 +1019,7 @@ var PersistMemory = class {
   conversations;
   integrations;
   health;
+  agent;
   #http;
   constructor(options) {
     this.#http = new HttpClient(options);
@@ -946,6 +1035,7 @@ var PersistMemory = class {
     this.conversations = new Conversations(this.#http);
     this.integrations = new Integrations(this.#http);
     this.health = new Health(this.#http);
+    this.agent = new Agent(this.#http);
   }
   /**
    * An escape hatch for an endpoint this package has not caught up with.
@@ -1287,7 +1377,7 @@ function shortDate(iso) {
 }
 
 // src/help.ts
-var VERSION = "0.1.1";
+var VERSION = "0.1.2";
 var PACKAGE = "@persistmemory/cli";
 var HELP = `
   pm \u2014 PersistMemory from your terminal
@@ -1334,6 +1424,7 @@ var HELP = `
 
     status                           is the service healthy
     requests                         file requests waiting for you to approve
+    requests get <id>                write a finished one to a file here
 
     update                           install the newest version
     uninstall                        remove pm from this machine
@@ -1477,8 +1568,8 @@ async function startLoopback(options = {}) {
   const timeoutMs = options.timeoutMs ?? 5 * 60 * 1e3;
   let resolveCallback;
   let rejectCallback;
-  const received = new Promise((resolve6, reject) => {
-    resolveCallback = resolve6;
+  const received = new Promise((resolve7, reject) => {
+    resolveCallback = resolve7;
     rejectCallback = reject;
   });
   const server = createServer((request, response) => {
@@ -1504,9 +1595,9 @@ async function startLoopback(options = {}) {
     response.end(donePage(callback));
     resolveCallback?.(callback);
   });
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve7, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", resolve6);
+    server.listen(0, "127.0.0.1", resolve7);
   });
   const address = server.address();
   if (address === null || typeof address === "string") {
@@ -1768,7 +1859,7 @@ function safeEqual(a, b) {
 }
 async function openBrowser(url) {
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve7, reject) => {
     const child = spawn(command, args, {
       stdio: "ignore",
       // Detached so closing the terminal does not close the browser, and so
@@ -1777,7 +1868,7 @@ async function openBrowser(url) {
     });
     child.once("error", reject);
     child.unref();
-    resolve6();
+    resolve7();
   });
 }
 async function describe(response) {
@@ -1839,13 +1930,13 @@ async function currentCredential(resolved, deps) {
 // src/context.ts
 import { createInterface } from "node:readline";
 async function askOnTty(prompt) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const readline = createInterface({ input: process.stdin, output: process.stdout });
     readline.question(prompt, (answer3) => {
       readline.close();
-      resolve6(answer3.trim());
+      resolve7(answer3.trim());
     });
-    readline.once("close", () => resolve6(""));
+    readline.once("close", () => resolve7(""));
   });
 }
 var ETX = "";
@@ -1854,13 +1945,13 @@ var BACKSPACE = "\b";
 async function readSecretFromTty(prompt) {
   const input = process.stdin;
   if (!input.isTTY) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const readline = createInterface({ input });
       readline.once("line", (line) => {
         readline.close();
-        resolve6(line.trim());
+        resolve7(line.trim());
       });
-      readline.once("close", () => resolve6(""));
+      readline.once("close", () => resolve7(""));
     });
   }
   process.stdout.write(prompt);
@@ -1868,14 +1959,14 @@ async function readSecretFromTty(prompt) {
   input.setRawMode?.(true);
   input.resume();
   input.setEncoding("utf8");
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let value = "";
     const finish2 = () => {
       input.removeListener("data", onData);
       input.setRawMode?.(previouslyRaw);
       input.pause();
       process.stdout.write("\n");
-      resolve6(value.trim());
+      resolve7(value.trim());
     };
     const onData = (chunk) => {
       for (const character of chunk) {
@@ -1912,8 +2003,8 @@ async function readStdin() {
 // src/commands/agent.ts
 import { hostname } from "node:os";
 import { homedir as homedir2 } from "node:os";
-import { resolve as resolve3 } from "node:path";
-import { readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
+import { join as join4, resolve as resolve3 } from "node:path";
+import { readFileSync as readFileSync4, readdirSync, statSync as statSync2 } from "node:fs";
 
 // src/files.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync, statSync, writeFileSync as writeFileSync3 } from "node:fs";
@@ -1926,11 +2017,13 @@ var OutsideWorkspace = class extends Error {
 };
 var TooLarge = class extends Error {
   constructor(path, bytes, limit) {
-    super(`${path} is ${Math.round(bytes / 1024)} KB, over the ${Math.round(limit / 1024)} KB limit.`);
+    const say = (value) => value >= 1024 * 1024 ? `${(value / (1024 * 1024)).toFixed(1)} MB` : `${Math.round(value / 1024)} KB`;
+    super(`${path} is ${say(bytes)}, over the ${say(limit)} limit.`);
     this.name = "TooLarge";
   }
 };
 var MAX_READ_BYTES = 512 * 1024;
+var MAX_TRANSFER_BYTES = 100 * 1024 * 1024;
 function realLocation(absolute) {
   let existing = absolute;
   const trailing = [];
@@ -2044,19 +2137,41 @@ async function answer(context, apiUrl, token, roots, request) {
     return { ok: false, error: error instanceof Error ? error.message : "refused" };
   }
   let bytes;
+  let filename = request.path.split("/").pop() ?? "file";
+  if (request.kind === "list_dir") {
+    try {
+      const stats = statSync2(located);
+      if (!stats.isDirectory()) return { ok: false, error: `${request.path} is not a folder.` };
+      const entries = readdirSync(located, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).slice(0, MAX_LISTED).map((entry) => {
+        if (entry.isDirectory()) return `${entry.name}/`;
+        try {
+          return `${entry.name}  ${sizeOf(join4(located, entry.name))}`;
+        } catch {
+          return entry.name;
+        }
+      }).sort();
+      const listing = entries.length > 0 ? entries.join("\n") : "(empty)";
+      bytes = Buffer.from(`${request.path}
+
+${listing}
+`, "utf8");
+      filename = `${request.path.split("/").filter(Boolean).pop() ?? "listing"}.txt`;
+      const grant = await upload(apiUrl, token, filename, bytes);
+      return grant;
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : "could not list it" };
+    }
+  }
   try {
     const stats = statSync2(located);
     if (!stats.isFile()) return { ok: false, error: `${request.path} is not a file.` };
-    if (stats.size > MAX_READ_BYTES) {
-      return {
-        ok: false,
-        error: new TooLarge(request.path, stats.size, MAX_READ_BYTES).message
-      };
-    }
     bytes = readFileSync4(located);
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : "could not read it" };
   }
+  return upload(apiUrl, token, filename, bytes);
+}
+async function upload(apiUrl, token, filename, bytes) {
   const grant = await fetch(`${apiUrl}/api/v1/agent/upload-url`, {
     method: "POST",
     headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
@@ -2068,13 +2183,17 @@ async function answer(context, apiUrl, token, roots, request) {
       // No content type is sent: this machine has a path, not a declaration.
       // The server resolves it from the name against the one table that knows
       // which types it can read, and tells us below what it decided.
-      filename: request.path.split("/").pop() ?? "file"
+      filename
     })
   });
   if (!grant.ok) {
     return { ok: false, error: await said(grant, "could not get an upload url") };
   }
-  const { uploadUrl, contentType } = await grant.json();
+  const { uploadUrl, contentType, maxBytes } = await grant.json();
+  const limit = maxBytes ?? MAX_TRANSFER_BYTES;
+  if (bytes.length > limit) {
+    return { ok: false, error: new TooLarge(filename, bytes.length, limit).message };
+  }
   const put = await fetch(uploadUrl, {
     method: "PUT",
     // The type the grant was signed for. Anything else is refused.
@@ -2086,6 +2205,13 @@ async function answer(context, apiUrl, token, roots, request) {
   if (!stored.attachToken) return { ok: false, error: "the upload returned no reference" };
   return { ok: true, attachToken: stored.attachToken, bytes: bytes.length };
 }
+var MAX_LISTED = 200;
+function sizeOf(path) {
+  const size = statSync2(path).size;
+  if (size < 1024) return `${size} B`;
+  if (size < 1024 * 1024) return `${Math.round(size / 1024)} KB`;
+  return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
 async function agentCommand(context) {
   const credential = context.resolved.credential;
   if (!credential) {
@@ -2195,7 +2321,10 @@ async function agentCommand(context) {
 }
 
 // src/commands/requests.ts
+import { existsSync as existsSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
 async function requestsCommand(context) {
+  if (context.args.words[1] === "get") return collectCommand(context);
   const credential = context.resolved.credential;
   if (!credential) {
     context.error("Sign in first: pm auth login");
@@ -2233,16 +2362,53 @@ async function requestsCommand(context) {
   context.print("They cannot be approved from here \u2014 see `pm help requests`.");
   return 0;
 }
+async function collectCommand(context) {
+  const credential = context.resolved.credential;
+  if (!credential) {
+    context.error("Sign in first: pm auth login");
+    return 1;
+  }
+  const id = context.args.words[2];
+  if (!id) {
+    context.error("Which request? `pm requests` lists them with their ids.");
+    return 2;
+  }
+  const apiUrl = context.resolved.apiUrl.replace(/\/+$/, "");
+  const link = await fetch(
+    `${apiUrl}/api/v1/agent/request/${encodeURIComponent(id)}/download`,
+    { headers: { authorization: `Bearer ${credential.token}` } }
+  );
+  if (!link.ok) {
+    const body = await link.json().catch(() => void 0);
+    context.error(body?.error?.message ?? `Could not prepare that file (${link.status}).`);
+    return 1;
+  }
+  const { downloadUrl, filename } = await link.json();
+  const file = await fetch(downloadUrl);
+  if (!file.ok) {
+    context.error(`The download refused it (${file.status}). Links expire in minutes \u2014 try again.`);
+    return 1;
+  }
+  const name = stringFlag(context.args, "output", "o") ?? filename;
+  const target = resolve4(name);
+  if (existsSync4(target)) {
+    context.error(`${target} already exists. Pass --output to write somewhere else.`);
+    return 1;
+  }
+  writeFileSync4(target, new Uint8Array(await file.arrayBuffer()));
+  context.print(`Wrote ${target}`);
+  return 0;
+}
 
 // src/workspace.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname3, join as join4, resolve as resolvePath } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname3, join as join5, resolve as resolvePath } from "node:path";
 var WORKSPACE_FILE = ".persistmemory.json";
 function findWorkspace(from = process.cwd()) {
   let dir = resolvePath(from);
   for (; ; ) {
-    const file = join4(dir, WORKSPACE_FILE);
-    if (existsSync4(file)) {
+    const file = join5(dir, WORKSPACE_FILE);
+    if (existsSync5(file)) {
       const config = readWorkspace(file);
       if (config) return { file, dir, config };
     }
@@ -2264,8 +2430,8 @@ function readWorkspace(file) {
   }
 }
 function writeWorkspace(dir, config) {
-  const file = join4(dir, WORKSPACE_FILE);
-  writeFileSync4(file, `${JSON.stringify(config, null, 2)}
+  const file = join5(dir, WORKSPACE_FILE);
+  writeFileSync5(file, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   return file;
 }
@@ -2534,9 +2700,9 @@ function message(error) {
 }
 
 // src/commands/maintain.ts
-import { existsSync as existsSync5, rmSync } from "node:fs";
+import { existsSync as existsSync6, rmSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { dirname as dirname4, resolve as resolve5 } from "node:path";
+import { dirname as dirname4, resolve as resolve6 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function updateCommand(context) {
   const manager = installer();
@@ -2578,7 +2744,7 @@ Delete the file it runs from: ${processPath()}`
   return 0;
 }
 async function deleteCommand(context) {
-  if (!existsSync5(context.paths.dir)) {
+  if (!existsSync6(context.paths.dir)) {
     context.print(`Nothing to delete: ${context.paths.dir} does not exist.`);
     return 0;
   }
@@ -2607,7 +2773,7 @@ async function deleteCommand(context) {
   return 0;
 }
 function removeEverything(context) {
-  const dir = resolve5(context.paths.dir);
+  const dir = resolve6(context.paths.dir);
   if (dir === "/" || dir.split("/").filter(Boolean).length < 2) {
     context.error(`Refusing to delete ${dir}: that does not look like a data directory.`);
     return;
@@ -2619,7 +2785,7 @@ function installer() {
 }
 function processPath() {
   try {
-    return resolve5(dirname4(fileURLToPath(import.meta.url)));
+    return resolve6(dirname4(fileURLToPath(import.meta.url)));
   } catch {
     return process.argv[1] ?? "";
   }
@@ -2631,12 +2797,12 @@ import { randomUUID } from "node:crypto";
 import { relative as relative2 } from "node:path";
 
 // src/events.ts
-import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6 } from "node:fs";
-import { join as join5 } from "node:path";
+import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join6 } from "node:path";
 function openSessionLog(paths, id) {
-  const directory = join5(paths.dir, "sessions");
+  const directory = join6(paths.dir, "sessions");
   mkdirSync3(directory, { recursive: true, mode: 448 });
-  const path = join5(directory, `${id}.jsonl`);
+  const path = join6(directory, `${id}.jsonl`);
   return {
     id,
     path,
@@ -2648,7 +2814,7 @@ function openSessionLog(paths, id) {
       }
     },
     read() {
-      if (!existsSync6(path)) return [];
+      if (!existsSync7(path)) return [];
       return readFileSync6(path, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -2726,9 +2892,9 @@ async function sessionCommand(context) {
   context.print(`  Ask anything. /help for commands, /exit to leave.
 `);
   const readline = createInterface2({ input: process.stdin, output: process.stdout });
-  const ask = (prompt) => new Promise((resolve6) => {
-    readline.question(prompt, resolve6);
-    readline.once("close", () => resolve6(void 0));
+  const ask = (prompt) => new Promise((resolve7) => {
+    readline.question(prompt, resolve7);
+    readline.once("close", () => resolve7(void 0));
   });
   const root = process.cwd();
   let running = true;