@timqi/pier 0.1.3 → 0.1.4

package/README.md

@@ -37,8 +37,8 @@ otherwise).
 **The first start generates a password and prints it once.** Lost it?
 `sqlite3 ~/.pier/db/pier.db 'DELETE FROM auth'` and restart. Open
 `http://localhost:3141`, sign in; **Console → Settings** configures Models,
-Agent, Channels, the public URL, password and master key; **New session** picks
-the directory the agent's shell runs in.
+Agent, Channels, Vault, the public URL, password and master key; **New session**
+picks the directory the agent's shell runs in.
 
 ## Configure Pi
 
@@ -67,7 +67,12 @@ Console → Settings:
   copy of yours registering the same tool makes Pier's stand down) and the
   managed CLI tools (`rtk`, `rg`, `fd`, `wt`, `jq`, or your own as a
   [ubix](https://github.com/timqi/ubix) block), installed into
-  `~/.pier/tools/bin`, first on every session's PATH.
+  `~/.pier/tools/bin`, first on every session's PATH beside the `pier` shim
+  Pier writes there at start.
+- **Vault** — named secrets an agent's commands receive through `pier vault
+  run` without the value entering its context (`docs/design/07-vault.md`);
+  `pier slack` and `pier task` reach the running Pier the same way
+  (`docs/design/08-cli-socket.md`).
 
 On first credential access an existing `auth.json` is imported into the sealed
 store and renamed `auth.json.imported`; literal keys in `models.json` likewise

package/dist/agent/config.js

@@ -15,9 +15,15 @@ const PROJECT_FILES = ["AGENTS.md"];
 const READONLY_FILES = ["settings.json"];
 const SNAPSHOT_FILES = ["SYSTEM.md", "AGENTS.md", "models.json", "settings.json"];
 /** What a first boot writes (docs/deploy.md says why each key): the list the
- *  Console installs into, and Pi's attribution headers off — a server is not a
- *  person to survey. Every other key stays Pi's default by omission. */
-const SEED_SETTINGS = { packages: [], enableInstallTelemetry: false };
+ *  Console installs into, Pi's attribution headers off — a server is not a
+ *  person to survey — and a retry budget of minutes, because an unattended
+ *  instance has nobody to re-ask after Pi's 14-second default gives up. Every
+ *  other key stays Pi's default by omission. */
+const SEED_SETTINGS = {
+    packages: [],
+    enableInstallTelemetry: false,
+    retry: { maxRetries: 5, baseDelayMs: 5000 },
+};
 /** Pier owns the Pi runtime dir; main.ts exports it as PI_CODING_AGENT_DIR. */
 export const defaultAgentDir = () => process.env.PI_CODING_AGENT_DIR ?? pierPath("pi");
 /** Stable mask: mapped back by field, without exposing key fragments. */

package/dist/agent/events.js

@@ -33,8 +33,7 @@ function systemOrigin(message) {
     }
     if (origin.kind === "task-message" &&
         typeof origin.messageId === "string" &&
-        (origin.messageKind === "steer" || origin.messageKind === "follow_up" ||
-            origin.messageKind === "progress" || origin.messageKind === "decision" || origin.messageKind === "reply"))
+        (origin.messageKind === "steer" || origin.messageKind === "follow_up"))
         return shape;
     return null;
 }

package/dist/agent/packages.js

@@ -14,8 +14,6 @@ const log = logger("packages");
 /** Set by how long a released fix may sit unnoticed, like update.ts. */
 const CHECK_EVERY_MS = 24 * 60 * 60_000;
 const KINDS = { extensions: "extension", skills: "skill" };
-/** The state line for a skill whose tool this instance is not given (docs/design/03). */
-const FOLLOWS_TOOL = "follows Channels → agent tool";
 /** Written by `rtk init -g --agent pi` (the rtk block's `post_install` hook): a `local` file whose
  *  switch is the rtk tool's, so a settings.json pattern would fight the tool. */
 const RTK_FILE = join("extensions", "rtk.ts");
@@ -160,16 +158,12 @@ export class PiPackageStore {
             kind: "extension", name, path: `<inline:${name}>`, enabled: on.includes(name),
             state: on.includes(name) ? shadowedBuiltin(name) : null,
         }));
-        const gone = new Set(this.pier.tools.filter((t) => t.skill && !(t.available?.() ?? true)).map((t) => t.skill));
         for (const dir of this.skillDirs) {
             for (const entry of (await fs.readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory())) {
                 const path = join(dir, entry.name, "SKILL.md");
                 if (!existsSync(path))
                     continue;
-                pkg.resources.push({
-                    kind: "skill", name: entry.name, path, enabled: !off.includes(entry.name),
-                    state: gone.has(entry.name) ? FOLLOWS_TOOL : null,
-                });
+                pkg.resources.push({ kind: "skill", name: entry.name, path, enabled: !off.includes(entry.name), state: null });
             }
         }
     }

package/dist/agent/pi.js

@@ -3,7 +3,7 @@
 // Pi SDK. No Pi type may appear in an exported signature.
 import { realpathSync } from "node:fs";
 import { basename, dirname, join, sep } from "node:path";
-import { createAgentSession, CredentialSynchronizationError, DefaultResourceLoader, defineTool, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSession, CredentialSynchronizationError, DefaultResourceLoader, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { inlineExtensions } from "../extensions/index.js";
 import { SESSION_TITLE_MAX } from "../core/types.js";
 import { logger } from "../log.js";
@@ -140,14 +140,6 @@ export const standDownShadowed = (base) => {
         }),
     };
 };
-/** A skill's description is resident in every prompt; one pointing at a tool
- *  this session was not given is a route the agent cannot take. */
-export const standDownUndocumented = (tools, skills) => {
-    const gone = new Set(tools.filter((tool) => tool.skill && !(tool.available?.() ?? true)).map((tool) => tool.skill));
-    if (!gone.size)
-        return skills;
-    return skills.filter((skill) => !gone.has(skill.name));
-};
 export class PiSession {
     pi;
     pinned;
@@ -400,7 +392,6 @@ export class PiSession {
     }
 }
 export class PiAgentFactory {
-    extraTools;
     instructions;
     skillPaths;
     credentials;
@@ -409,9 +400,9 @@ export class PiAgentFactory {
     pier;
     titleModel;
     listings;
-    constructor(extraTools = [], 
-    /** Getters are read per session open, so a Console change reaches the next
-     *  session without a restart. Appended as a context file so the user's own
+    constructor(
+    /** Read per session open, so a Console change reaches the next session
+     *  without a restart; appended as a context file so the user's own
      *  instructions still win. */
     instructions = () => "", 
     /** Loaded per session, never installed into the user's skill directories. */
@@ -423,7 +414,6 @@ export class PiAgentFactory {
     pier = () => ({ extensions: [], skillsOff: [] }), titleModel = () => undefined, 
     /** Injected so a test needs no session directory or database. */
     listings = new IndexedListing()) {
-        this.extraTools = extraTools;
         this.instructions = instructions;
         this.skillPaths = skillPaths;
         this.credentials = credentials;
@@ -628,7 +618,7 @@ export class PiAgentFactory {
             // same name is Pi's to switch (settings.json).
             skillsOverride: (base) => ({
                 ...base,
-                skills: standDownUndocumented(this.extraTools, base.skills.filter((skill) => !skillsOff.includes(skill.name) || !this.skillPaths.some((dir) => skill.filePath.startsWith(dir + sep)))),
+                skills: base.skills.filter((skill) => !skillsOff.includes(skill.name) || !this.skillPaths.some((dir) => skill.filePath.startsWith(dir + sep))),
             }),
             extensionFactories: [
                 { name: "pier-bash-timeout", factory: bashTimeoutDefault, hidden: true },
@@ -651,36 +641,6 @@ export class PiAgentFactory {
         return this.providerConfig.withWrite(() => this.openSnapshot(cwd, sessionManager, opts));
     }
     async openSnapshot(cwd, sessionManager, opts) {
-        let live;
-        // Per open: an unconfigured tool would cost context on every turn and answer nothing.
-        const active = this.extraTools.filter((tool) => tool.available?.() ?? true);
-        const customTools = active.map((tool) => defineTool({
-            name: tool.name,
-            label: tool.label,
-            description: tool.description,
-            parameters: tool.parameters,
-            execute: async (_id, params, signal) => {
-                const caller = live?.sessionId ?? "unknown";
-                log.debug(`tool ${tool.name} called by ${caller}`);
-                try {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                // Pretty-printing costs ~20% more tokens and buys the model nothing.
-                                text: JSON.stringify(await tool.execute(params, caller, signal)),
-                            },
-                        ],
-                        details: {},
-                    };
-                }
-                catch (err) {
-                    // Pi turns this into tool-result text: the right recovery, the wrong record.
-                    log.warn(`tool ${tool.name} failed for ${caller}`, err);
-                    throw err;
-                }
-            },
-        }));
         // A locked store is a refusal with a reason here, not "provider not
         // configured" later. Before appendSessionInfo, so nothing is written.
         this.credentials?.assertUnlocked();
@@ -696,11 +656,10 @@ export class PiAgentFactory {
         const created = await createAgentSession({
             cwd,
             sessionManager,
-            customTools,
             modelRuntime: runtime,
             resourceLoader: await this.resourceLoader(cwd),
         });
-        live = created.session;
+        const live = created.session;
         // Pi defaults to one follow-up per turn boundary, so N queued messages cost
         // N turns. The agent's setter flips only the in-memory queue;
         // `session.setFollowUpMode` would persist it to Pi's settings.json.

package/dist/channels/config.js

@@ -1,23 +1,31 @@
 // Channel config persistence and the permission gate every adapter shares: one
 // JSON document per platform, so a surface configuring one reads and writes one row.
 import { randomInt } from "node:crypto";
-import { pierDb } from "../db.js";
-import { isSealed } from "../secrets.js";
 import { defaultChannelConfig, } from "./types.js";
 const BIND_CODE_TTL_MS = 10 * 60_000;
 /** Six symbols out of 36 is 2 billion, but a caller who may retry forever only
  *  needs the TTL; five wrong tries void the code instead. */
 const BIND_CODE_TRIES = 5;
 const BIND_CODE_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+/** Where each platform's credentials live in the vault — fixed names, so a
+ *  skill and the Console agree without a setting. Migration 24 spells the same
+ *  table in SQL. Telegram authenticates with one token. */
+const CREDENTIAL_NAMES = {
+    telegram: { token: "TELEGRAM_TOKEN" },
+    slack: { token: "SLACK_TOKEN", appToken: "SLACK_APP_TOKEN" },
+    lark: { token: "LARK_APP_ID", appToken: "LARK_APP_SECRET" },
+};
+const credentials = (platform) => Object.entries(CREDENTIAL_NAMES[platform]);
 export class ChannelStore {
-    secrets;
     db;
+    vault;
     cache = new Map();
-    /** Without `secrets` (tests), tokens persist as given. A locked store throws
-     *  rather than serving a token it cannot read. */
-    constructor(db = pierDb(), secrets) {
-        this.secrets = secrets;
+    /** The row never holds a credential: `token`/`appToken` are filled from the
+     *  vault on read and filed there on save. A locked vault throws rather than
+     *  serving a token it cannot read. */
+    constructor(db, vault) {
         this.db = db;
+        this.vault = vault;
     }
     /** Private: handed out, a caller could mutate config without saving. */
     cached(platform) {
@@ -28,11 +36,8 @@ export class ChannelStore {
         const config = row
             ? { ...defaultChannelConfig(), ...JSON.parse(row.json) }
             : defaultChannelConfig();
-        if (this.secrets) {
-            for (const key of ["token", "appToken"]) {
-                if (isSealed(config[key]))
-                    config[key] = this.secrets.decrypt(config[key]);
-            }
+        for (const [key, name] of credentials(platform)) {
+            config[key] = this.vault.get(name) ?? "";
         }
         this.cache.set(platform, config);
         return config;
@@ -41,16 +46,21 @@ export class ChannelStore {
         return structuredClone(this.cached(platform));
     }
     save(platform, config) {
+        // The cache holds plaintext; the row holds neither key. Only a changed
+        // credential touches the vault, so its `updated` is the rotation, not the
+        // last chat discovered; an emptied field removes the row.
+        const before = this.cached(platform);
+        for (const [key, name] of credentials(platform)) {
+            if (config[key] === before[key])
+                continue;
+            if (config[key])
+                this.vault.seal(name, config[key]);
+            else
+                this.vault.remove(name);
+        }
         // Cloned, so the caller's object cannot reach into the cache later.
         this.cache.set(platform, structuredClone(config));
-        // The cache holds plaintext; only the row is sealed.
-        const stored = this.secrets ? structuredClone(config) : config;
-        if (this.secrets) {
-            for (const key of ["token", "appToken"]) {
-                if (stored[key])
-                    stored[key] = this.secrets.encrypt(stored[key]);
-            }
-        }
+        const { token: _token, appToken: _appToken, ...stored } = config;
         this.db.prepare(`
       INSERT INTO channels(platform, json) VALUES (?, ?)
       ON CONFLICT(platform) DO UPDATE SET json = excluded.json

package/dist/channels/routes.js

@@ -70,9 +70,6 @@ export function registerChannelRoutes(app, store, runtime) {
             enabled: asBool(body.enabled),
             token: kept(asString(body.token), current.token),
             appToken: kept(asString(body.appToken), current.appToken),
-            // Absent means "on": a client that predates the field must not silently
-            // switch off a capability the operator never touched.
-            agentTool: body.agentTool === undefined ? current.agentTool : asBool(body.agentTool),
             requireMention: asBool(body.requireMention),
             requireBind: asBool(body.requireBind),
             topicMode: asBool(body.topicMode),

package/dist/channels/slack-api.js

@@ -21,18 +21,24 @@ export class SlackApi {
     appToken;
     log;
     openSocket;
+    retries;
     socketRunning = false;
     constructor(token, appToken, log = () => { }, 
     /** Injected in tests. */
-    openSocket = (url) => new WebSocket(url)) {
+    openSocket = (url) => new WebSocket(url), 
+    /** How many rate-limit waits one call sits through. The adapter takes one:
+     *  a turn must not hang for minutes. A batch process (`pier slack`) takes more. */
+    retries = 1) {
         this.token = token;
         this.appToken = appToken;
         this.log = log;
         this.openSocket = openSocket;
+        this.retries = retries;
     }
     /** Slack accepts a JSON body only on write methods; a read method silently
      *  ignores it and reports the parameter missing (`users.info` answers
-     *  `user_not_found`). So reads go form-encoded. */
+     *  `user_not_found`). So reads go form-encoded. Public for the long tail of
+     *  read methods `pier slack` needs and the adapter never calls. */
     async read(method, params) {
         const form = new URLSearchParams();
         for (const [key, value] of Object.entries(params)) {
@@ -41,7 +47,7 @@ export class SlackApi {
         }
         return this.call(method, form);
     }
-    async call(method, payload, token = this.token, retry = true) {
+    async call(method, payload, token = this.token, tries = this.retries) {
         const form = payload instanceof URLSearchParams;
         const res = await fetch(`${BASE}/${method}`, {
             method: "POST",
@@ -54,16 +60,17 @@ export class SlackApi {
             body: form ? payload.toString() : JSON.stringify(payload),
             signal: AbortSignal.timeout(30_000),
         });
+        const body = (await res.json().catch(() => null));
         // A long turn split into chunks hits ~1 msg/s per channel; the header
-        // carries the exact wait. Obeyed once; a second 429 throws.
-        if (res.status === 429 && retry) {
+        // carries the exact wait. Some methods say `ratelimited` in a 200 body
+        // instead. Obeyed `retries` times; the next one throws.
+        if ((res.status === 429 || body?.error === "ratelimited") && tries > 0) {
             const after = Number(res.headers.get("retry-after") ?? "1");
             if (Number.isFinite(after) && after <= 60) {
                 await new Promise((r) => setTimeout(r, (after + 1) * 1000));
-                return this.call(method, payload, token, false);
+                return this.call(method, payload, token, tries - 1);
             }
         }
-        const body = (await res.json().catch(() => null));
         if (!body)
             throw new Error(`slack ${method}: ${res.status} with no JSON body`);
         if (!body.ok)
@@ -259,7 +266,7 @@ export class SlackApi {
     }
     /** Three calls is Slack's current upload (`files.upload` is retired); the
      *  upload host is not the Web API and answers plain text. */
-    async uploadFile(channel, threadTs, file) {
+    async uploadFile(channel, threadTs, file, comment) {
         const slot = await this.read("files.getUploadURLExternal", { filename: file.name, length: file.bytes.length }).catch((err) => {
             // The manifest is only applied when an app is created; name the fix.
             if (!/missing_scope/.test(String(err)))
@@ -279,10 +286,12 @@ export class SlackApi {
         });
         if (!put.ok)
             throw new Error(`slack file upload: ${put.status}`);
-        await this.call("files.completeUploadExternal", {
+        const done = await this.call("files.completeUploadExternal", {
             files: [{ id: slot.file_id, title: file.name }],
             channel_id: channel,
-            thread_ts: threadTs,
+            thread_ts: threadTs || undefined,
+            initial_comment: comment,
         });
+        return { id: done.files?.[0]?.id ?? slot.file_id };
     }
 }