@goodfish/jarvy 0.8.0 → 0.9.0

package/dist/server/cli.js

@@ -301,7 +301,8 @@ function messageView(message) {
     echoOf: message.echoOf,
     replyTo: message.replyTo,
     reactions: message.reactions,
-    quotes: message.quotes
+    quotes: message.quotes,
+    folded: message.folded
   };
 }
 
@@ -680,6 +681,7 @@ function channelRoutes({ chats }) {
     const input = await readJson(c);
     return c.json(messageView(chats.react(c.get("actorId"), c.req.param("id"), input.emoji, input.on ?? true)));
   });
+  routes.put("/messages/:id/fold", jsonBody, async (c) => c.json(messageView(chats.fold(c.get("actorId"), c.req.param("id"), (await readJson(c)).folded))));
   routes.put("/chats/:id/mute", jsonBody, async (c) => c.json(chat(c.get("actorId"), chats.mute(c.get("actorId"), c.req.param("id"), (await readJson(c)).muted).id)));
   routes.put("/chats/:id/pin", jsonBody, async (c) => c.json(chat(c.get("actorId"), chats.pin(c.get("actorId"), c.req.param("id"), (await readJson(c)).pinned).id)));
   routes.get("/members/:id/dms", (c) => c.json({ chats: chats.botDirects(c.get("actorId"), c.req.param("id")).map((item) => chatView(item, (id) => chats.member(id))) }));
@@ -857,6 +859,7 @@ function environmentRoutes(bots) {
     const input = await readJson(c);
     return c.json(await machines.scan({ host: input.host, port: input.port, user: input.user }));
   });
+  routes.post("/keys", async (c) => c.json(await machines.prepareKey(), 201));
   routes.post("/", jsonBody, async (c) => {
     const input = await readJson(c);
     return c.json(await machines.add({
@@ -866,9 +869,14 @@ function environmentRoutes(bots) {
       user: input.user,
       directory: input.directory,
       password: input.password,
+      ...input.keyId !== void 0 ? { keyId: input.keyId } : {},
       hostKeys: hostKeys(input.hostKeys)
     }), 201);
   });
+  routes.put("/:id/password", jsonBody, async (c) => {
+    const input = await readJson(c);
+    return c.json(await machines.setPassword(c.req.param("id"), input.password));
+  });
   routes.put("/:id", jsonBody, async (c) => {
     const input = await readJson(c);
     return c.json(machines.update(c.req.param("id"), { name: input.name, directory: input.directory }));
@@ -890,7 +898,12 @@ function environmentRoutes(bots) {
   });
   routes.post("/requests/:chatId/:messageId", jsonBody, async (c) => {
     const input = await readJson(c);
-    return c.json(messageView(await machines.fulfil(c.get("actorId"), c.req.param("chatId"), c.req.param("messageId"), { password: input.password })));
+    return c.json(messageView(await machines.fulfil(
+      c.get("actorId"),
+      c.req.param("chatId"),
+      c.req.param("messageId"),
+      { password: input.password, ...input.keyId !== void 0 ? { keyId: input.keyId } : {} }
+    )));
   });
   return routes;
 }
@@ -1513,6 +1526,34 @@ function migrateTasks(db) {
   }
 }
 
+// src/server/infra/storage/migrations/ssh-login-schema.ts
+function migrateSshLogin(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version >= 24) return;
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    db.exec("ALTER TABLE environments ADD COLUMN password TEXT; PRAGMA user_version=24");
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+
+// src/server/infra/storage/migrations/fold-schema.ts
+function migrateFolds(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version >= 25) return;
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    db.exec("ALTER TABLE messages ADD COLUMN folded_at INTEGER; PRAGMA user_version=25;");
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+
 // src/server/infra/storage/migrations/schema.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
@@ -1635,7 +1676,7 @@ function migrateRuntime(db) {
 // src/server/infra/storage/migrations/schema.ts
 function migrateDatabase(db, cipher) {
   const version = db.prepare("PRAGMA user_version").get().user_version;
-  if (version > 23) throw new Error(`Unsupported database version: ${version}`);
+  if (version > 25) throw new Error(`Unsupported database version: ${version}`);
   migratePrototype(db);
   if (version >= 5) {
     migrateRuntime(db);
@@ -1656,6 +1697,8 @@ function migrateDatabase(db, cipher) {
     migrateSecrets(db, cipher);
     migrateSsh(db);
     migrateTasks(db);
+    migrateSshLogin(db);
+    migrateFolds(db);
     return;
   }
   db.exec("PRAGMA foreign_keys=OFF; BEGIN IMMEDIATE");
@@ -1734,6 +1777,8 @@ function migrateDatabase(db, cipher) {
   migrateSecrets(db, cipher);
   migrateSsh(db);
   migrateTasks(db);
+  migrateSshLogin(db);
+  migrateFolds(db);
 }
 
 // src/server/infra/storage/chat-repository.ts
@@ -2095,6 +2140,10 @@ var InteractionRepository = class {
     return this.db.prepare(`SELECT DISTINCT member_id AS id FROM chat_states WHERE muted=1 AND chat_id IN
       (SELECT id FROM chats WHERE id=? UNION SELECT parent_id FROM chats WHERE id=? AND parent_id IS NOT NULL)`).all(chatId, chatId).map((row) => row.id);
   }
+  /** Folds a message to one line in the interface, or unfolds it (A60); its content and everything else stay. */
+  setFolded(messageId, folded) {
+    this.db.prepare("UPDATE messages SET folded_at=? WHERE id=?").run(folded ? Date.now() : null, messageId);
+  }
   setPinned(memberId, chatId, pinned) {
     this.chats.assertAccess(memberId, chatId);
     this.db.prepare(`INSERT INTO chat_states(chat_id,member_id,pinned) VALUES(?,?,?)
@@ -2117,7 +2166,7 @@ var QuoteRepository = class {
 };
 
 // src/server/infra/storage/chat-repository.ts
-var MESSAGE_COLUMNS = "id,chat_id AS chatId,sequence,sender_id AS senderId,content,created_at AS createdAt,history_id AS historyId,tool_call_id AS toolCallId,question,echo_of AS echoOf,reply_to AS replyTo";
+var MESSAGE_COLUMNS = "id,chat_id AS chatId,sequence,sender_id AS senderId,content,created_at AS createdAt,history_id AS historyId,tool_call_id AS toolCallId,question,echo_of AS echoOf,reply_to AS replyTo,folded_at AS foldedAt";
 var CHAT_COLUMNS = `c.id,c.type,c.title,c.owner_id AS ownerId,c.created_at AS createdAt,c.updated_at AS updatedAt,
   c.section_id AS sectionId,c.topic,c.parent_id AS parentId,c.root_message_id AS rootMessageId,c.status,
   (SELECT content FROM messages WHERE chat_id=c.id ORDER BY sequence DESC LIMIT 1) AS lastMessage,
@@ -2272,12 +2321,12 @@ var ChatRepository = class {
     return rows2.map((row) => this.messageFromRow(row));
   }
   /** Search every chat the member can read: its DMs and channels and their threads (newest first). `within` keeps
-   * one chat, a channel with its threads. */
-  searchAll(actorId, query, limit, within) {
-    const scope = within ? "AND (c.id=? OR c.parent_id=?)" : "";
+   * one chat, a channel with its threads; `sender` keeps one member's messages. */
+  searchAll(actorId, query, limit, within, sender) {
+    const scope = (within ? "AND (c.id=? OR c.parent_id=?) " : "") + (sender ? "AND m.sender_id=?" : "");
     const rows2 = this.db.prepare(`SELECT ${MESSAGE_COLUMNS.split(",").map((column) => `m.${column}`).join(",")} FROM messages m JOIN chats c ON c.id=m.chat_id
       JOIN chat_members cm ON cm.chat_id=COALESCE(c.parent_id,c.id) AND cm.member_id=? AND cm.can_read=1
-      WHERE instr(lower(m.content),lower(?))>0 ${scope} ORDER BY m.position DESC LIMIT ?`).all(actorId, query, ...within ? [within, within] : [], limit);
+      WHERE instr(lower(m.content),lower(?))>0 ${scope} ORDER BY m.position DESC LIMIT ?`).all(actorId, query, ...within ? [within, within] : [], ...sender ? [sender] : [], limit);
     return rows2.map((row) => this.messageFromRow(row));
   }
   /** Channels and threads the member can read whose title, topic or notice / summary contains the query (newest first). */
@@ -2296,9 +2345,10 @@ var ChatRepository = class {
     const row = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE id=?`).get(id);
     return row && this.canAccess(actorId, row.chatId) ? this.messageFromRow(row) : null;
   }
-  search(actorId, chatId, query, limit) {
+  search(actorId, chatId, query, limit, sender) {
     this.assertAccess(actorId, chatId);
-    const rows2 = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE chat_id=? AND instr(lower(content),lower(?))>0 ORDER BY sequence DESC LIMIT ?`).all(chatId, query, limit);
+    const rows2 = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE chat_id=? AND instr(lower(content),lower(?))>0 ${sender ? "AND sender_id=?" : ""}
+      ORDER BY sequence DESC LIMIT ?`).all(chatId, query, ...sender ? [sender] : [], limit);
     return rows2.map((row) => this.messageFromRow(row));
   }
   sentActivity(actorId, senderId, before, limit) {
@@ -2329,7 +2379,8 @@ var ChatRepository = class {
       echoOf: row.echoOf === null ? null : { id: row.echoOf, title: this.db.prepare("SELECT title FROM chats WHERE id=?").get(row.echoOf).title },
       replyTo: row.replyTo === null ? null : this.quote(row.replyTo),
       reactions: this.interactions.reactions(row.id),
-      quotes: this.quotes.of(row.id)
+      quotes: this.quotes.of(row.id),
+      folded: row.foldedAt !== null
     };
   }
   /** What a reply shows of the message it answers: who wrote it and the start of its content, with its quotes ("" is attachments only). */
@@ -2391,14 +2442,15 @@ var ChatRepository = class {
             toolCallId: draft.source?.toolCallId ?? null,
             question: null,
             echoOf: chatId,
-            replyTo: null
+            replyTo: null,
+            foldedAt: null
           });
         }
       }
       const file = this.db.prepare("SELECT name FROM attachments WHERE message_id=? ORDER BY created_at,rowid LIMIT 1").get(id);
       const title = draft.content ? previewQuotes(draft.content, draft.quotes ?? []).slice(0, 46).replace(/\s+/g, " ") : file?.name.slice(0, 46) ?? "";
       this.db.prepare("UPDATE chats SET title=CASE WHEN title='' AND ?=1 THEN ? ELSE title END,updated_at=? WHERE id=?").run(sequence, title, createdAt, chatId);
-      const message = this.messageFromRow({ id, chatId, sequence, senderId: actorId, content: draft.content, createdAt, historyId: draft.source?.historyId ?? null, toolCallId: draft.source?.toolCallId ?? null, question, echoOf: null, replyTo: draft.replyTo ?? null });
+      const message = this.messageFromRow({ id, chatId, sequence, senderId: actorId, content: draft.content, createdAt, historyId: draft.source?.historyId ?? null, toolCallId: draft.source?.toolCallId ?? null, question, echoOf: null, replyTo: draft.replyTo ?? null, foldedAt: null });
       this.db.exec("COMMIT");
       return { message, duplicate: false, ...echo ? { echo } : {} };
     } catch (error) {
@@ -2884,7 +2936,7 @@ var EnvironmentRepository = class {
   }
   addSsh(input, id = randomUUID7()) {
     const { host, port, user, home, platform } = input;
-    this.db.prepare("INSERT INTO environments(id,owner_id,kind,name,connection,directory,key,host_keys,created_at) VALUES(?,?,'ssh',?,?,?,?,?,?)").run(
+    this.db.prepare("INSERT INTO environments(id,owner_id,kind,name,connection,directory,key,host_keys,password,created_at) VALUES(?,?,'ssh',?,?,?,?,?,?,?)").run(
       id,
       this.ownerId(),
       input.name,
@@ -2892,20 +2944,34 @@ var EnvironmentRepository = class {
       input.directory,
       this.cipher.seal(input.privateKey, `environment:${id}`),
       JSON.stringify(input.hostKeys),
+      input.password ? this.cipher.seal(input.password, `environment-password:${id}`) : null,
       Date.now()
     );
     return this.get(id);
   }
+  /** `password`: a new one for a machine reached with its password; null goes back to the key (A59). */
   updateSsh(id, input) {
+    if (input.password !== void 0) this.db.prepare("UPDATE environments SET password=? WHERE id=? AND kind='ssh'").run(input.password === null ? null : this.cipher.seal(input.password, `environment-password:${id}`), id);
     if (input.name !== void 0) this.db.prepare("UPDATE environments SET name=? WHERE id=? AND kind='ssh'").run(input.name, id);
     if (input.directory !== void 0) this.db.prepare("UPDATE environments SET directory=? WHERE id=? AND kind='ssh'").run(input.directory, id);
     if (input.hostKeys !== void 0) this.db.prepare("UPDATE environments SET host_keys=? WHERE id=? AND kind='ssh'").run(JSON.stringify(input.hostKeys), id);
   }
-  /** The machine's private key (null when it doesn't open under this installation's key) and accepted host keys. */
+  /** The machine's private key (null when it doesn't open under this installation's key), its password when it is
+   * reached with one (A59; `passwordUnreadable` when it is kept but doesn't open) and the accepted host keys. */
   sshSecrets(id) {
-    const row = this.db.prepare("SELECT key, host_keys AS hostKeys FROM environments WHERE id=? AND kind='ssh' AND deleted_at IS NULL").get(id);
+    const row = this.db.prepare("SELECT key, password, host_keys AS hostKeys FROM environments WHERE id=? AND kind='ssh' AND deleted_at IS NULL").get(id);
     if (!row) return null;
-    return { privateKey: row.key ? this.cipher.open(row.key, `environment:${id}`) : null, hostKeys: row.hostKeys ? JSON.parse(row.hostKeys) : { keys: [], fingerprints: [] } };
+    const password = row.password ? this.cipher.open(row.password, `environment-password:${id}`) : null;
+    return {
+      privateKey: row.key ? this.cipher.open(row.key, `environment:${id}`) : null,
+      password,
+      passwordUnreadable: !!row.password && password === null,
+      hostKeys: row.hostKeys ? JSON.parse(row.hostKeys) : { keys: [], fingerprints: [] }
+    };
+  }
+  /** Whether a machine is reached with its password rather than the key (A59). */
+  usesPassword(id) {
+    return !!this.db.prepare("SELECT password FROM environments WHERE id=? AND kind='ssh'").get(id)?.password;
   }
   /** The Bots that may use an environment. */
   grantees(environmentId) {
@@ -2918,7 +2984,7 @@ var EnvironmentRepository = class {
       const moved = this.db.prepare("SELECT id FROM bots WHERE current_environment_id=?").all(id).map((row) => row.id);
       this.db.prepare("UPDATE bots SET current_environment_id=home_environment_id WHERE current_environment_id=?").run(id);
       this.db.prepare("DELETE FROM environment_grants WHERE environment_id=?").run(id);
-      this.db.prepare("UPDATE environments SET deleted_at=?, key=NULL WHERE id=? AND kind='ssh'").run(Date.now(), id);
+      this.db.prepare("UPDATE environments SET deleted_at=?, key=NULL, password=NULL WHERE id=? AND kind='ssh'").run(Date.now(), id);
       this.db.exec("COMMIT");
       return moved;
     } catch (error) {
@@ -5102,6 +5168,15 @@ var ChatService = class {
     if (added) this.dispatcher.dispatch(deliveries);
     return this.repository.message(actorId, messageId);
   }
+  /** Folds a message to one line in the owner's interface, or unfolds it (A60). Nobody is told: a Bot reads it as before. */
+  fold(actorId, messageId, folded) {
+    if (typeof folded !== "boolean") throw new ChatError(400, "Invalid folded state");
+    const message = this.repository.message(actorId, messageId);
+    if (!message) throw new ChatError(404, "Message not found");
+    this.repository.interactions.setFolded(messageId, folded);
+    this.notifySaved(message.chatId);
+    return this.repository.message(actorId, messageId);
+  }
   mute(actorId, chatId, muted) {
     if (typeof muted !== "boolean") throw new ChatError(400, "Invalid muted");
     this.repository.interactions.setMuted(actorId, chatId, muted);
@@ -5126,10 +5201,11 @@ var ChatService = class {
   unreadMessages(actorId, chatId, limit) {
     return this.repository.unreadMessages(actorId, chatId, limit);
   }
-  searchAll(actorId, query, limit = 30, within) {
+  /** `sender`: only that member's messages (a Bot looking for what it sent itself). */
+  searchAll(actorId, query, limit = 30, within, sender) {
     if (!query.trim() || query.length > 500 || !Number.isInteger(limit) || limit < 1 || limit > 100) throw new ChatError(400, "Invalid search query or limit");
     if (within) this.repository.assertAccess(actorId, within);
-    return this.repository.searchAll(actorId, query.trim(), limit, within);
+    return this.repository.searchAll(actorId, query.trim(), limit, within, sender);
   }
   /** The search box: channels and threads by title, topic or notice / summary, and messages by text, with the chat
    * each message is in. `within` searches one chat (a channel with its threads) and returns no chats. */
@@ -5200,9 +5276,9 @@ var ChatService = class {
   message(actorId, id) {
     return this.repository.message(actorId, id);
   }
-  search(actorId, chatId, query, limit = 30) {
+  search(actorId, chatId, query, limit = 30, sender) {
     if (!query.trim() || query.length > 500 || !Number.isInteger(limit) || limit < 1 || limit > 100) throw new ChatError(400, "Invalid search query or limit");
-    return this.repository.search(actorId, chatId, query, limit);
+    return this.repository.search(actorId, chatId, query, limit, sender);
   }
   notifySaved(chatId) {
     try {
@@ -5891,7 +5967,7 @@ function environmentTools(lookup, secrets) {
   const access = async (path) => {
     if (!await current().exists(path)) throw Object.assign(new Error(`ENOENT: no such file or directory, access '${path}'`), { code: "ENOENT" });
   };
-  const readFile4 = (path) => current().readFile(path), writeFile6 = (path, content2) => current().writeFile(path, content2);
+  const readFile4 = (path) => current().readFile(path), writeFile5 = (path, content2) => current().writeFile(path, content2);
   const cwd = current().cwd;
   const definitions2 = [
     relocated(createBashToolDefinition(cwd, { operations: {
@@ -5915,8 +5991,8 @@ function environmentTools(lookup, secrets) {
     } }), current),
     // Pictures go to the model as pictures; the kind comes from a file's first bytes, as Pi's local read does.
     createReadToolDefinition(cwd, { operations: { readFile: readFile4, access, detectImageMimeType: async (path) => imageKind(await current().head(path, IMAGE_SNIFF_BYTES)) } }),
-    createWriteToolDefinition(cwd, { operations: { writeFile: writeFile6, mkdir: (path) => current().mkdir(path) } }),
-    createEditToolDefinition(cwd, { operations: { readFile: readFile4, writeFile: writeFile6, access } })
+    createWriteToolDefinition(cwd, { operations: { writeFile: writeFile5, mkdir: (path) => current().mkdir(path) } }),
+    createEditToolDefinition(cwd, { operations: { readFile: readFile4, writeFile: writeFile5, access } })
   ];
   return definitions2.map((definition) => inside(definition, lookup, pinned));
 }
@@ -6917,7 +6993,7 @@ import { dirname as dirname5, join as join9, posix } from "node:path";
 // src/server/infra/env/ssh.ts
 import { spawn as spawn2 } from "node:child_process";
 import { mkdirSync as mkdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { mkdir as mkdir4, mkdtemp as mkdtemp2, readFile as readFile3, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir4, mkdtemp as mkdtemp2, readFile as readFile3, rm as rm3 } from "node:fs/promises";
 import { join as join8 } from "node:path";
 import { HostKeyChangedError, HostKeyUnknownError, RemoteExecutionEnv as RemoteExecutionEnv2, detectPlatform, scanHostKey, sshArguments, sshConnection } from "@earendil-works/pi-env";
 var SshFault = class extends Error {
@@ -6950,26 +7026,31 @@ async function generateKey(runtime, comment) {
     await rm3(directory, { recursive: true, force: true });
   }
 }
+function publicKeyOf(privateKey, comment) {
+  try {
+    const body = Buffer.from(privateKey.replace(/-----[^-]+-----/g, "").replace(/\s+/g, ""), "base64"), magic = "openssh-key-v1\0";
+    if (body.subarray(0, magic.length).toString("latin1") !== magic) return null;
+    let at2 = magic.length;
+    const field2 = () => {
+      const size = body.readUInt32BE(at2);
+      const value2 = body.subarray(at2 + 4, at2 + 4 + size);
+      at2 += 4 + size;
+      return value2;
+    };
+    field2();
+    field2();
+    field2();
+    if (body.readUInt32BE(at2) !== 1) return null;
+    at2 += 4;
+    const blob = field2(), type = blob.subarray(4, 4 + blob.readUInt32BE(0)).toString("latin1");
+    return `${type} ${blob.toString("base64")} ${comment}`;
+  } catch {
+    return null;
+  }
+}
 async function installKey(address2, runtime, hostKeys2, password, publicKey) {
-  await withFiles(runtime, SCAN_ALIAS, hostKeys2, null, async (files, directory) => {
-    const askpass = join8(directory, "askpass");
-    await writeFile3(askpass, `#!/bin/sh
-printf '%s\\n' "$JARVY_SSH_PASSWORD"
-`, { mode: 448 });
-    const { SSH_AUTH_SOCK: _agent, ...env } = process.env;
-    const args = [
-      "-o",
-      "BatchMode=no",
-      "-o",
-      "PreferredAuthentications=keyboard-interactive,password",
-      "-o",
-      "PubkeyAuthentication=no",
-      "-o",
-      "NumberOfPasswordPrompts=1",
-      "-o",
-      "ConnectTimeout=15",
-      ...sshArguments({ ...target(address2, SCAN_ALIAS), ...files })
-    ];
+  const access = { ...address2, runtime, alias: SCAN_ALIAS, hostKeys: hostKeys2, privateKey: "", password };
+  await withFiles(access, async (files) => {
     const script = [
       "umask 077",
       'mkdir -p "$HOME/.ssh"',
@@ -6978,29 +7059,23 @@ printf '%s\\n' "$JARVY_SSH_PASSWORD"
       "IFS= read -r key",
       `grep -qxF "$key" "$f" || printf '%s\\n' "$key" >> "$f"`
     ].join("\n");
-    await runSsh(
-      address2,
-      args,
-      `sh -c ${quote(script)}`,
-      `${publicKey}
-`,
-      { ...env, SSH_ASKPASS: askpass, SSH_ASKPASS_REQUIRE: "force", DISPLAY: env.DISPLAY ?? "none", JARVY_SSH_PASSWORD: password }
-    );
+    await runSsh(access, files, `sh -c ${quote(script)}`, `${publicKey}
+`, "password");
   });
 }
 async function probeHost(access) {
-  return withFiles(access.runtime, access.alias, access.hostKeys, access.privateKey, async (files) => {
+  return withFiles(access, async (files) => {
     try {
       const remote = await detectPlatform({ ...target(access, access.alias), ...files });
       if (remote.platform !== "linux" && remote.platform !== "darwin") throw new SshFault("ssh_unsupported", `Unsupported system: ${remote.platform}`);
       return { platform: remote.platform, home: remote.home };
     } catch (error) {
-      throw classify(error, access);
+      throw classify(error, access, access.password ? "password" : "key");
     }
   });
 }
 async function removeKey(access, comment) {
-  await withFiles(access.runtime, access.alias, access.hostKeys, access.privateKey, async (files) => {
+  await withFiles(access, async (files) => {
     const script = [
       "umask 077",
       'f="$HOME/.ssh/authorized_keys"',
@@ -7010,13 +7085,13 @@ async function removeKey(access, comment) {
       'rm -f "$f.jarvy"',
       "exit $s"
     ].join("\n");
-    await runSsh(access, sshArguments({ ...target(access, access.alias), ...files }), `sh -c ${quote(script)}`);
+    await runSsh(access, files, `sh -c ${quote(script)}`, "", access.password ? "password" : "key");
   });
 }
 function sshEnvironment(id, access, directory, temp, onLog) {
   mkdirSync4(access.runtime, { recursive: true, mode: 448 });
   const folder = join8(access.runtime, `open-${id}-${process.pid}-${Date.now().toString(36)}`);
-  const files = writeFilesSync(folder, access.alias, access.hostKeys, access.privateKey);
+  const files = writeFilesSync(folder, access);
   const { connection } = sshConnection({ ...target(access, access.alias), ...files, ...onLog ? { onLog } : {} });
   return overDurable(id, "ssh", new RemoteExecutionEnv2({ connection, id: `ssh:${id}`, cwd: directory }), {
     passEnv: false,
@@ -7033,29 +7108,39 @@ function clearRuntime(runtime) {
 function target(address2, alias2) {
   return { host: address2.host, port: address2.port, user: address2.user, hostKeyAlias: alias2, configFile: "/dev/null" };
 }
-async function withFiles(runtime, alias2, hostKeys2, privateKey, work) {
-  await mkdir4(runtime, { recursive: true, mode: 448 });
-  const directory = await mkdtemp2(join8(runtime, "use-"));
+async function withFiles(access, work) {
+  await mkdir4(access.runtime, { recursive: true, mode: 448 });
+  const directory = await mkdtemp2(join8(access.runtime, "use-"));
   try {
-    return await work(writeFilesSync(directory, alias2, hostKeys2, privateKey), directory);
+    return await work(writeFilesSync(directory, access));
   } finally {
     await rm3(directory, { recursive: true, force: true });
   }
 }
-function writeFilesSync(directory, alias2, hostKeys2, privateKey) {
+function writeFilesSync(directory, access) {
   mkdirSync4(directory, { recursive: true, mode: 448 });
   const knownHostsFile = join8(directory, "known_hosts");
-  writeFileSync3(knownHostsFile, hostKeys2.map((key) => `${alias2} ${key}
+  writeFileSync3(knownHostsFile, access.hostKeys.map((key) => `${access.alias} ${key}
 `).join(""), { mode: 384 });
-  if (privateKey === null) return { knownHostsFile };
+  if (access.password) {
+    const secret = join8(directory, "password"), askpass = join8(directory, "askpass"), ssh = join8(directory, "ssh");
+    writeFileSync3(secret, `${access.password}
+`, { mode: 384 });
+    writeFileSync3(askpass, `#!/bin/sh
+exec cat ${quote(secret)}
+`, { mode: 448 });
+    writeFileSync3(ssh, ["#!/bin/sh", `exec env -u SSH_AUTH_SOCK SSH_ASKPASS=${quote(askpass)} SSH_ASKPASS_REQUIRE=force DISPLAY=none ssh -o BatchMode=no -o PreferredAuthentications=keyboard-interactive,password -o PubkeyAuthentication=no -o NumberOfPasswordPrompts=1 -o ConnectTimeout=15 "$@"`, ""].join("\n"), { mode: 448 });
+    return { knownHostsFile, ssh };
+  }
   const identityFile = join8(directory, "key");
-  writeFileSync3(identityFile, privateKey.endsWith("\n") ? privateKey : `${privateKey}
+  writeFileSync3(identityFile, access.privateKey.endsWith("\n") ? access.privateKey : `${access.privateKey}
 `, { mode: 384 });
   return { knownHostsFile, identityFile };
 }
-function runSsh(address2, args, command, stdin = "", env) {
-  return run("ssh", [...args, command], stdin, env).catch((error) => {
-    throw classify(error, address2);
+function runSsh(access, files, command, stdin, how) {
+  const { ssh, ...rest } = files;
+  return run(ssh ?? "ssh", [...sshArguments({ ...target(access, access.alias), ...rest }), command], stdin).catch((error) => {
+    throw classify(error, access, how);
   });
 }
 function run(program, args, stdin = "", env) {
@@ -7079,13 +7164,20 @@ function run(program, args, stdin = "", env) {
     child.stdin.end(stdin);
   });
 }
-function classify(error, address2) {
+function classify(error, address2, how = "key") {
   if (error instanceof SshFault) return error;
   const text4 = error instanceof Error ? error.message : String(error), where2 = `${address2.user}@${address2.host}:${address2.port}`;
   if (error instanceof HostKeyChangedError || /REMOTE HOST IDENTIFICATION HAS CHANGED|Host key verification failed/.test(text4))
     return new SshFault("ssh_host_key_changed", `The host key of ${where2} is not the one accepted`);
   if (error instanceof HostKeyUnknownError) return new SshFault("ssh_host_key_changed", `The host key of ${where2} is not the one accepted`);
-  if (/Permission denied|Too many authentication failures/.test(text4)) return new SshFault("ssh_auth_failed", `${where2} refused the login`);
+  const denied = /Permission denied \(([^)]*)\)/.exec(text4);
+  if (denied || /Permission denied|Too many authentication failures/.test(text4)) {
+    const methods = denied ? denied[1].split(",").map((method) => method.trim()) : [];
+    if (how === "password" && methods.length && !methods.some((method) => method === "password" || method === "keyboard-interactive"))
+      return new SshFault("ssh_password_refused", `${where2} doesn't accept password logins`);
+    if (how === "key") return new SshFault("ssh_key_refused", `${where2} didn't accept Jarvy's key`);
+    return new SshFault("ssh_auth_failed", `${where2} refused the password`);
+  }
   if (/Connection refused|timed out|No route to host|Could not resolve|Network is unreachable|Connection closed|No host key received/i.test(text4))
     return new SshFault("ssh_unreachable", `${where2} can't be reached: ${text4.split("\n").pop()}`);
   return new SshFault("ssh_failed", text4.split("\n").slice(-3).join(" ").slice(0, 300) || `ssh ${where2} failed`);
@@ -7095,6 +7187,7 @@ var quote = (text4) => `'${text4.replaceAll("'", "'\\''")}'`;
 // src/server/service/bot/machines.ts
 var HOST = /^(?!-)[A-Za-z0-9._:-]{1,253}$/;
 var USER = /^(?!-)[A-Za-z0-9._][A-Za-z0-9._-]{0,63}$/;
+var PREPARED_MS = 60 * 6e4;
 var SshMachines = class {
   /** `changed`: what Bots may use changed, so the owner's page reloads them. */
   constructor(store, chats, changed = () => {
@@ -7106,6 +7199,7 @@ var SshMachines = class {
     clearRuntime(this.runtime);
   }
   runtime;
+  prepared = /* @__PURE__ */ new Map();
   list() {
     return this.store.environments.sshMachines().map((record3) => this.view(record3));
   }
@@ -7116,30 +7210,68 @@ var SshMachines = class {
   async scan(input) {
     return this.wrap(() => scanHost(address(input), this.runtime));
   }
-  /** Makes a key, installs it with the password, checks a login with it, then saves the machine; the password is
-   * used for that one login only. Nothing is saved when any step fails. */
+  /** A key for a machine the owner will add its public half to themselves; `keyId` then adds the machine. */
+  async prepareKey() {
+    const now = Date.now();
+    for (const [keyId2, key2] of this.prepared) if (key2.until < now) this.prepared.delete(keyId2);
+    const id = randomUUID12(), key = await this.wrap(() => generateKey(this.runtime, keyComment(id)));
+    this.prepared.set(id, { id, ...key, until: now + PREPARED_MS });
+    return { keyId: id, publicKey: key.publicKey };
+  }
+  /** Adds a machine and saves it once a login works; nothing is saved when a step fails. With `password`, Jarvy makes
+   * a key and installs it with that password; when the machine then refuses the key, the password itself is kept
+   * (sealed) and used to log in (A59), and the key stays installed for when keys are allowed. With `keyId`, the owner
+   * has added that prepared key to the machine, and a login with it is checked. */
   async add(input, grantTo) {
     const where2 = address(input), name3 = this.freeName(text3(input.name, 40) || `${where2.user}@${where2.host}`);
-    if (typeof input.password !== "string" || !input.password) throw new ChatError(400, "A password is needed to install the key", "ssh_password_missing");
+    const password = typeof input.password === "string" && input.password ? input.password : null;
+    const prepared = typeof input.keyId === "string" ? this.prepared.get(input.keyId) : void 0;
+    if (!password && input.keyId === void 0) throw new ChatError(400, "A password is needed to install the key", "ssh_password_missing");
+    if (!password && (!prepared || prepared.until < Date.now())) throw new ChatError(409, "That key is no longer kept; show a new one and add it to the machine", "ssh_key_expired");
     if (!input.hostKeys.keys.length) throw new ChatError(400, "The host keys are missing; scan the machine first");
     directoryIn("/", input.directory);
-    const id = randomUUID12(), comment = keyComment(id);
+    const id = prepared && !password ? prepared.id : randomUUID12(), comment = keyComment(id);
     const record3 = await this.wrap(async () => {
-      const key = await generateKey(this.runtime, comment), access = { ...where2, runtime: this.runtime, alias: alias(id), hostKeys: input.hostKeys.keys, privateKey: key.privateKey };
-      await installKey(where2, this.runtime, input.hostKeys.keys, input.password, key.publicKey);
+      const key = prepared && !password ? prepared : await generateKey(this.runtime, comment);
+      const access = { ...where2, runtime: this.runtime, alias: alias(id), hostKeys: input.hostKeys.keys, privateKey: key.privateKey };
+      const save = (remote, kept) => this.store.environments.addSsh({
+        name: name3,
+        ...where2,
+        ...remote,
+        directory: directoryIn(remote.home, input.directory),
+        hostKeys: input.hostKeys,
+        privateKey: key.privateKey,
+        ...kept ? { password: kept } : {}
+      }, id);
+      if (!password) return save(await probeHost(access));
+      await installKey(where2, this.runtime, input.hostKeys.keys, password, key.publicKey);
       try {
-        const remote = await probeHost(access);
-        return this.store.environments.addSsh({ name: name3, ...where2, ...remote, directory: directoryIn(remote.home, input.directory), hostKeys: input.hostKeys, privateKey: key.privateKey }, id);
+        try {
+          return save(await probeHost(access));
+        } catch (error) {
+          if (!(error instanceof SshFault) || error.code !== "ssh_key_refused") throw error;
+          return save(await probeHost({ ...access, password }), password);
+        }
       } catch (error) {
-        await removeKey(access, comment).catch(() => {
+        await removeKey(password ? { ...access, password } : access, comment).catch(() => {
         });
         throw error;
       }
     });
+    if (prepared) this.prepared.delete(prepared.id);
     if (grantTo) this.store.environments.grant(record3.id, grantTo.botId, grantTo.by);
     this.changed();
     return this.view(record3);
   }
+  /** A new password for a machine reached with its password, checked with a login before it is kept. */
+  async setPassword(id, password) {
+    const record3 = this.need(id);
+    if (typeof password !== "string" || !password) throw new ChatError(400, "A password is needed", "ssh_password_missing");
+    if (!this.store.environments.usesPassword(id)) throw new ChatError(409, "This machine is reached with Jarvy's key, not a password");
+    await this.wrap(() => probeHost({ ...this.access(record3), password }));
+    this.store.environments.updateSsh(id, { password });
+    return this.get(id);
+  }
   update(id, input) {
     const record3 = this.need(id);
     const name3 = input.name === void 0 ? void 0 : text3(input.name, 40);
@@ -7152,11 +7284,23 @@ var SshMachines = class {
     this.changed();
     return this.get(id);
   }
-  /** Scans the machine again: `changed` when it no longer presents the keys the owner accepted. */
+  /** Scans the machine again: `changed` when it no longer presents the keys the owner accepted. A machine reached
+   * with its password whose keys are unchanged is tried with Jarvy's key: once that works, the password is dropped
+   * and the key is used from then on (A59). `machine` is how it stands after. */
   async check(id) {
     const record3 = this.need(id), accepted = this.store.environments.sshSecrets(id).hostKeys;
-    const hostKeys2 = await this.scan(this.addressOf(record3));
-    return { hostKeys: hostKeys2, changed: hostKeys2.keys.some((key) => !accepted.keys.includes(key)) };
+    const hostKeys2 = await this.scan(this.addressOf(record3)), changed = hostKeys2.keys.some((key) => !accepted.keys.includes(key));
+    if (!changed && this.store.environments.usesPassword(id)) {
+      const { password: _password, ...withKey } = this.access(record3);
+      try {
+        await probeHost(withKey);
+        this.store.environments.updateSsh(id, { password: null });
+        this.changed();
+      } catch (error) {
+        if (!(error instanceof SshFault) || error.code !== "ssh_key_refused") throw this.fault(error);
+      }
+    }
+    return { hostKeys: hostKeys2, changed, machine: this.get(id) };
   }
   /** The owner accepts the keys the machine presents now (after a reinstall, say). */
   async trust(id, fingerprints) {
@@ -7214,8 +7358,8 @@ var SshMachines = class {
     };
     return { question: { question: input.purpose, options: [{ label: "Add", value: "add" }], multiple: false, allowCustom: false, machine } };
   }
-  /** The owner's answer on a request card: adds the machine with the password (or grants the one already added) to
-   * the Bot that asked, then settles the card. The password never enters the message. */
+  /** The owner's answer on a request card: adds the machine with the password or a prepared key (or grants the one
+   * already added) to the Bot that asked, then settles the card. The password never enters the message. */
   async fulfil(actorId, chatId, messageId, input) {
     const message = this.chats.message(actorId, messageId), ask = message?.question?.machine;
     if (!message || message.chatId !== chatId || !ask || message.question?.state !== "pending") throw new ChatError(409, "The question is already settled", "question_closed");
@@ -7225,7 +7369,16 @@ var SshMachines = class {
     if (existing) {
       this.store.environments.grant(existing.id, botId, by);
       this.changed();
-    } else await this.add({ name: ask.name, host: ask.host, port: ask.port, user: ask.user, directory: ask.directory ?? void 0, password: input.password, hostKeys: ask.hostKeys }, { botId, by });
+    } else await this.add({
+      name: ask.name,
+      host: ask.host,
+      port: ask.port,
+      user: ask.user,
+      directory: ask.directory ?? void 0,
+      password: input.password,
+      ...input.keyId !== void 0 ? { keyId: input.keyId } : {},
+      hostKeys: ask.hostKeys
+    }, { botId, by });
     return this.chats.questions.respond(actorId, chatId, messageId, { action: "answer", selected: [0] });
   }
   /** The machine a request card added or granted, by its address. */
@@ -7245,7 +7398,9 @@ var SshMachines = class {
       directory: record3.directory ?? spec.home ?? "",
       platform: spec.platform ?? "",
       fingerprints: secrets?.hostKeys.fingerprints ?? [],
-      botIds: this.store.environments.grantees(record3.id)
+      botIds: this.store.environments.grantees(record3.id),
+      login: secrets?.password || secrets?.passwordUnreadable ? "password" : "key",
+      publicKey: secrets?.privateKey ? publicKeyOf(secrets.privateKey, keyComment(record3.id)) : null
     };
   }
   need(id) {
@@ -7258,8 +7413,15 @@ var SshMachines = class {
   }
   access(record3) {
     const secrets = this.store.environments.sshSecrets(record3.id);
-    if (!secrets?.privateKey) throw new ChatError(409, "This machine's key doesn't open under this installation's master key; delete the machine and add it again", "ssh_key_unreadable");
-    return { ...this.addressOf(record3), runtime: this.runtime, alias: alias(record3.id), hostKeys: secrets.hostKeys.keys, privateKey: secrets.privateKey };
+    if (!secrets?.privateKey || secrets.passwordUnreadable) throw new ChatError(409, "This machine's key doesn't open under this installation's master key; delete the machine and add it again", "ssh_key_unreadable");
+    return {
+      ...this.addressOf(record3),
+      runtime: this.runtime,
+      alias: alias(record3.id),
+      hostKeys: secrets.hostKeys.keys,
+      privateKey: secrets.privateKey,
+      ...secrets.password ? { password: secrets.password } : {}
+    };
   }
   freeName(name3) {
     if (this.store.environments.sshMachines().some((record3) => record3.name === name3)) throw new ChatError(409, "Another machine has this name", "machine_name_taken");
@@ -7270,19 +7432,26 @@ var SshMachines = class {
     try {
       return await work();
     } catch (error) {
-      if (!(error instanceof SshFault)) throw error;
-      switch (error.code) {
-        case "ssh_auth_failed":
-          throw new ChatError(403, error.message, "ssh_auth_failed");
-        case "ssh_unreachable":
-          throw new ChatError(409, error.message, "ssh_unreachable");
-        case "ssh_host_key_changed":
-          throw new ChatError(409, error.message, "ssh_host_key_changed");
-        case "ssh_unsupported":
-          throw new ChatError(409, error.message, "ssh_unsupported");
-        default:
-          throw new ChatError(409, error.message, "ssh_failed", { detail: error.message });
-      }
+      throw this.fault(error);
+    }
+  }
+  fault(error) {
+    if (!(error instanceof SshFault)) return error;
+    switch (error.code) {
+      case "ssh_auth_failed":
+        return new ChatError(403, error.message, "ssh_auth_failed");
+      case "ssh_password_refused":
+        return new ChatError(403, error.message, "ssh_password_refused");
+      case "ssh_key_refused":
+        return new ChatError(403, error.message, "ssh_key_refused");
+      case "ssh_unreachable":
+        return new ChatError(409, error.message, "ssh_unreachable");
+      case "ssh_host_key_changed":
+        return new ChatError(409, error.message, "ssh_host_key_changed");
+      case "ssh_unsupported":
+        return new ChatError(409, error.message, "ssh_unsupported");
+      default:
+        return new ChatError(409, error.message, "ssh_failed", { detail: error.message });
     }
   }
 };
@@ -7634,7 +7803,7 @@ var Model = class {
 import { posix as posix2 } from "node:path";
 
 // src/server/infra/files/workspace.ts
-import { mkdir as mkdir5, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir5, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join10 } from "node:path";
 var LocalWorkspace = class {
   constructor(cwd) {
@@ -7649,14 +7818,14 @@ var LocalWorkspace = class {
   async writeTempFile(name3, content2, signal) {
     await this.prepare();
     const path = join10(this.tempDir, name3);
-    await writeFile4(path, content2, { encoding: "utf8", flag: "wx", mode: 384, signal });
+    await writeFile3(path, content2, { encoding: "utf8", flag: "wx", mode: 384, signal });
     return path;
   }
 };
 
 // src/server/infra/files/skills.ts
 import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4 } from "node:fs";
-import { mkdir as mkdir6, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname7, join as join11 } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -7682,7 +7851,7 @@ async function installSkills(workspace, skills) {
   for (const skill of skills) {
     const file = join11(workspace, skillPath(skill.name));
     await mkdir6(dirname7(file), { recursive: true });
-    await writeFile5(file, skill.content, "utf8");
+    await writeFile4(file, skill.content, "utf8");
   }
 }
 function skillsDir() {
@@ -8129,8 +8298,10 @@ var ChatTools = class {
     signal?.throwIfAborted();
     return messages.map((message) => messageRow(this.chats, this.bot, message, listing(message)));
   }
+  /** `mine`: only what this Bot sent; those messages carry the History ID of the turn that sent them (A21). */
   search(input) {
-    const found = input.chatId === void 0 ? this.chats.searchAll(this.bot, input.query, input.limit ?? 30) : this.chats.search(this.bot, this.chat(input.chatId).id, input.query, input.limit ?? 30);
+    const sender = input.mine ? this.bot : void 0;
+    const found = input.chatId === void 0 ? this.chats.searchAll(this.bot, input.query, input.limit ?? 30, void 0, sender) : this.chats.search(this.bot, this.chat(input.chatId).id, input.query, input.limit ?? 30, sender);
     const chats = /* @__PURE__ */ new Map();
     const chatOf = (id) => {
       if (!chats.has(id)) chats.set(id, this.chats.get(this.bot, id));
@@ -8219,8 +8390,13 @@ var definitions = {
     }, { additionalProperties: false })
   },
   "messages.search": {
-    description: "Search message text. With chatId, only that chat; without it, every chat you can see, and each result says which chat it is in. Results list their files like messages.read.",
-    schema: Type3.Object({ chatId: Type3.Optional(Type3.String()), query: Type3.String({ minLength: 1, maxLength: 500 }), limit: Type3.Optional(Type3.Integer({ minimum: 1, maximum: 100 })) }, { additionalProperties: false })
+    description: "Search message text. With chatId, only that chat; without it, every chat you can see, and each result says which chat it is in. Results list their files like messages.read. mine=true: only messages you sent; each carries the History ID of the turn that sent it.",
+    schema: Type3.Object({
+      chatId: Type3.Optional(Type3.String()),
+      query: Type3.String({ minLength: 1, maxLength: 500 }),
+      limit: Type3.Optional(Type3.Integer({ minimum: 1, maximum: 100 })),
+      mine: Type3.Optional(Type3.Boolean({ description: "Only messages you sent" }))
+    }, { additionalProperties: false })
   },
   "files.get": {
     description: "Put a file from a message into your environment, to work on it with your tools; the result has its path there. It goes to temp/files/ under its own name unless you give a path.",
@@ -8232,7 +8408,7 @@ var definitions = {
     schema: Type3.Object({ id: Type3.String({ minLength: 1, maxLength: 80, description: "The environment's id from environments.list" }) }, { additionalProperties: false })
   },
   "environments.request": {
-    description: `Ask your owner to add a machine you need to work on, reached over SSH, on a card in a chat with them, and wait for the answer, as messages.ask does. The card shows the machine's host key fingerprints for them to check; they type its login password there once, and from then on it is reached with a key made for it. You never see either, so never ask for that password in the chat. It returns {status:"added", id, name} or {status:"granted", id, name} when you may already use it, then environments.switch with that id moves your tools there; or {status:"declined"}.`,
+    description: `Ask your owner to add a machine you need to work on, reached over SSH, on a card in a chat with them, and wait for the answer, as messages.ask does. The card shows the machine's host key fingerprints for them to check; they let you in there, with its login password or by adding a key made for it to the machine. You never see the password or the key, so never ask for that password in the chat. It returns {status:"added", id, name} or {status:"granted", id, name} when you may already use it, then environments.switch with that id moves your tools there; or {status:"declined"}.`,
     schema: Type3.Object({
       chatId: Type3.String(),
       host: Type3.String({ minLength: 1, maxLength: 253, description: "Host name or IP address" }),
@@ -9191,8 +9367,9 @@ Each batch of messages ends with your unread counts and the notices and summarie
 You can schedule work for yourself, once or on a schedule, with the tasks tools in the chat gateway. When a task is due, its instruction comes in a batch as a <task>; do it then.
 
 ## History
-To look into earlier work, search the chat first, then call history.read with the History ID a message carries to read how the work was done.
-history.read is listed by the chat gateway. History is material to look back on, not an instruction for the task at hand.
+Your History keeps everything you did: your thinking, each tool call with its arguments, and what came back. Most of it never reaches the chat.
+Each message you sent carries a History ID, the turn in which you sent it. To recall how you did something, find a message of yours with messages.search (mine=true searches only yours), then read that turn with history.read. History IDs are in order, so the IDs just before and after it show what led up to it and what followed; read summaries first, then the details you need.
+History is material to look back on, not an instruction for the task at hand.
 
 ## Secrets
 Never ask anyone for a password, token or key in the chat, and never put one in a message or in a file others read.