@timqi/pier 0.1.2 → 0.1.4

package/dist/agent/pi.js

@@ -2,8 +2,8 @@
 // Implements the AgentFactory/AgentSession seam from src/core/types.ts on the
 // Pi SDK. No Pi type may appear in an exported signature.
 import { realpathSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { createAgentSession, CredentialSynchronizationError, DefaultResourceLoader, defineTool, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { basename, dirname, join, sep } from "node:path";
+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";
@@ -112,32 +112,34 @@ const bashTimeoutDefault = (pi) => {
         }
     });
 };
+/** What the last session open stood down, by bundled extension name: the
+ *  registry (agent/packages.ts) shows it as the row's state. Known only at
+ *  open, so a built-in no session has loaded since reads nothing. */
+const shadowed = new Map();
+export const shadowedBuiltin = (name) => shadowed.get(name) ?? null;
 /** Pi loads a bundled extension and its on-disk twin both, leaving two tools
  *  of one name; the copy the user put there wins, and the journal says so (§5). */
 export const standDownShadowed = (base) => {
     const inline = (ext) => ext.path.startsWith("<inline:");
-    const onDisk = new Set(base.extensions.filter((ext) => !inline(ext)).flatMap((ext) => [...ext.tools.keys()]));
-    if (!onDisk.size)
-        return base;
+    const onDisk = new Map(base.extensions.filter((ext) => !inline(ext)).flatMap((ext) => [...ext.tools.keys()].map((tool) => [tool, ext.path])));
     return {
         ...base,
         extensions: base.extensions.filter((ext) => {
-            const clash = inline(ext) && [...ext.tools.keys()].filter((tool) => onDisk.has(tool));
-            if (!clash || !clash.length)
+            if (!inline(ext))
                 return true;
-            log.info(`bundled ${ext.path} stood down — ${clash.join(", ")} already loaded from disk`);
+            const name = ext.path.slice("<inline:".length, -1);
+            const clash = [...ext.tools.keys()].filter((tool) => onDisk.has(tool));
+            if (!clash.length) {
+                shadowed.delete(name);
+                return true;
+            }
+            const from = onDisk.get(clash[0]);
+            shadowed.set(name, `stood down — ${clash.join(", ")} from ${from}`);
+            log.info(`bundled ${ext.path} stood down — ${clash.join(", ")} already loaded from ${from}`);
             return false;
         }),
     };
 };
-/** 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;
@@ -390,34 +392,34 @@ export class PiSession {
     }
 }
 export class PiAgentFactory {
-    extraTools;
     instructions;
     skillPaths;
     credentials;
     providerConfig;
     pinned;
-    enabledExtensions;
+    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. */
     skillPaths = [], 
     /** Optional only for bare test factories; an OAuth refresh persists here,
      *  never to a plaintext auth.json. */
-    credentials, providerConfig = new PiConfigStore(), pinned = () => [], enabledExtensions = () => [], titleModel = () => undefined, 
+    credentials, providerConfig = new PiConfigStore(), pinned = () => [], 
+    /** The built-in `pier` package's switches: bundled extensions on, Pier's own skills off. */
+    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;
         this.providerConfig = providerConfig;
         this.pinned = pinned;
-        this.enabledExtensions = enabledExtensions;
+        this.pier = pier;
         this.titleModel = titleModel;
         this.listings = listings;
     }
@@ -605,19 +607,22 @@ export class PiAgentFactory {
         await (await this.authRuntime()).logout(providerId, { signal: AbortSignal.timeout(15_000) });
     }
     async resourceLoader(cwd) {
+        const { extensions, skillsOff } = this.pier();
         const loader = new DefaultResourceLoader({
             cwd,
             agentDir: defaultAgentDir(),
             // The user's SYSTEM.md is appended after Pier's baseline, so it still wins.
             systemPromptOverride: pierSystemPrompt,
             additionalSkillPaths: this.skillPaths,
+            // Only Pier's own skills answer to the off-list; a user's skill of the
+            // same name is Pi's to switch (settings.json).
             skillsOverride: (base) => ({
                 ...base,
-                skills: standDownUndocumented(this.extraTools, base.skills),
+                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 },
-                ...inlineExtensions(this.enabledExtensions()),
+                ...inlineExtensions(extensions),
             ],
             extensionsOverride: standDownShadowed,
             agentsFilesOverride: (current) => {
@@ -633,39 +638,9 @@ export class PiAgentFactory {
         return loader;
     }
     open(cwd, sessionManager, opts = { cwd }) {
-        return this.providerConfig.withSnapshot(() => this.openSnapshot(cwd, sessionManager, opts));
+        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();
@@ -681,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 };
     }
 }