@timqi/pier 0.1.4 → 0.1.6

package/dist/channels/lark-outbound.js

@@ -50,6 +50,25 @@ export class LarkOutbound {
         if (lost)
             await this.api.replyCard(root, card([markdown(lost)]));
     }
+    /** The root, then one card inside its topic: on the phone a topic has its
+     *  own composer only once it has a reply. Answers the root's id. The handoff
+     *  writes no row when this throws, so a root left behind would invite a reply
+     *  into a thread nobody answers: it is taken back down. */
+    async open(chatId, note) {
+        const link = note.url ? `[Open on the web](${note.url})` : "(no public URL set — Settings → Instance)";
+        const { messageId: root } = await this.api.createCard(chatId, card([
+            markdown(`**Continued from web: ${note.title}**\n${link}\nReply in this thread to continue.`),
+        ]));
+        try {
+            await this.api.replyCard(root, card([markdown("Reply here to continue.")]));
+        }
+        catch (err) {
+            await this.api.deleteMessage(root)
+                .catch((e) => this.log(`orphan handoff root ${root} not deleted: ${String(e)}`));
+            throw err;
+        }
+        return root;
+    }
     /** Best-effort: a card sent before a restart keeps its row, logged. */
     async retire(messageId) {
         const known = this.sent.get(messageId);

package/dist/channels/lark-panel.js

@@ -1,14 +1,15 @@
-// Lark's half of the settings panel (panel.ts has the rest). Lark has no modal
-// a WebSocket app can open, so the typed answer is the panel patched into a
-// form card; the submit button's `name` carries the thread root.
+// Lark's half of the settings panel (panel.ts has the rest). No modal a
+// WebSocket app can open, so the typed answer is the panel patched into a form
+// card whose submit button's `name` carries the thread root; every callback
+// button's value carries the draft, so a tap after a reload lands on its card.
 import { button as cardButton, buttonRow, card, footer, formInput, markdown, } from "./lark-render.js";
-import { ChatPanel, CWD_PLACEHOLDER, CWD_TAIL, PANEL_PREFIX, } from "./panel.js";
+import { ChatPanel, CWD_DRAFT_TAIL, CWD_PLACEHOLDER, holdQuestion, PANEL_PREFIX, readDraft, } from "./panel.js";
 /** A form-submit button name: `cwdgo:<thread root>`. */
 export const CWD_SUBMIT_PREFIX = "cwdgo:";
 const CWD_FIELD = "cwd";
+const fresh = (root, messageId, draft) => ({ root, messageId, draft, dirs: [], sessions: [] });
 export class LarkPanel extends ChatPanel {
     deps;
-    platform = "lark";
     fence = ["`", "`"];
     constructor(deps) {
         super(deps);
@@ -19,25 +20,38 @@ export class LarkPanel extends ChatPanel {
         return text;
     }
     // --- rendering -------------------------------------------------------------
-    btn(b, root) {
-        return cardButton(b.label, { key: `${PANEL_PREFIX}${b.action}`, root });
+    btn(b, state) {
+        const draft = Object.keys(state.draft).length ? { draft: state.draft } : {};
+        return cardButton(b.label, { key: `${PANEL_PREFIX}${b.action}`, root: state.root, ...draft });
     }
-    render(view, root, note) {
+    render(view, state, note) {
         const elements = [
             ...view.groups.map((g) => markdown([`**${g.title}**${g.suffix ?? ""}`, ...g.lines].join("\n"))),
-            ...(view.picks?.length ? [buttonRow(view.picks.map((p) => this.btn(p, root)))] : []),
-            ...view.rows.filter((r) => r.length).map((row) => buttonRow(row.map((b) => this.btn(b, root)))),
+            ...(view.picks?.length ? [buttonRow(view.picks.map((p) => this.btn(p, state)))] : []),
+            ...view.rows.filter((r) => r.length).map((row) => buttonRow(row.map((b) => this.btn(b, state)))),
         ];
         if (note)
             elements.push(footer(note));
         return card(elements);
     }
-    async open(key, chatId, root) {
-        const sent = await this.deps.api.replyCard(root, this.render(await this.view(key, chatId), root));
-        this.remember(key, { chatId, root, messageId: sent.messageId, models: [] });
+    /** A card that cannot be posted must not look like nothing happening: the
+     *  topic gets the reason as a plain card. */
+    async open(key, root, question) {
+        const state = fresh(root, "", holdQuestion(question));
+        let sent;
+        try {
+            sent = await this.deps.api.replyCard(root, this.render(await this.view(key, state), state));
+        }
+        catch (err) {
+            this.deps.log(`panel open failed: ${String(err)}`);
+            await this.deps.api.replyCard(root, card([markdown(this.esc(`Could not open the panel: ${String(err)}`))]))
+                .catch((e) => this.deps.log(`panel open failure not posted: ${String(e)}`));
+            return;
+        }
+        this.remember(key, { ...state, messageId: sent.messageId });
     }
     async draw(state, view, note) {
-        await this.deps.api.patchCard(state.messageId, this.render(view, state.root, note))
+        await this.deps.api.patchCard(state.messageId, this.render(view, state, note))
             .catch((err) => this.deps.log(`panel edit failed: ${String(err)}`));
     }
     async erase(state) {
@@ -45,35 +59,36 @@ export class LarkPanel extends ChatPanel {
             .catch((err) => this.deps.log(`panel close failed: ${String(err)}`));
     }
     // --- actions ---------------------------------------------------------------
-    /** Returns false when the action is not ours. */
-    async onAction(action, key, payload, root) {
-        return this.dispatch(key, payload, action, () => this.open(key, action.chatId, root));
+    /** Returns false when the action is not ours. `run` delivers Start's
+     *  question as the tapper's message. */
+    async onAction(action, key, payload, root, run) {
+        return this.dispatch(key, payload, action, () => fresh(root, action.messageId, readDraft(action.value?.draft)), run);
     }
     // --- working directory (one typed answer, in a form card) -------------------
-    async promptCwd(key, state, _action) {
+    async promptCwd(_key, state, _action) {
         const form = {
             tag: "form",
             name: "cwd_form",
             elements: [
                 formInput(CWD_FIELD, "Working directory", CWD_PLACEHOLDER),
-                markdown(`An absolute path. ${CWD_TAIL}`),
+                markdown(`An absolute path. ${CWD_DRAFT_TAIL}`),
                 {
                     tag: "button",
-                    text: { tag: "plain_text", content: "Start" },
+                    text: { tag: "plain_text", content: "Set" },
                     type: "primary",
                     action_type: "form_submit",
                     name: `${CWD_SUBMIT_PREFIX}${state.root}`,
                 },
             ],
         };
-        await this.deps.api.patchCard(state.messageId, card([form, buttonRow([this.btn({ label: "Cancel", action: "panel" }, state.root)])])).catch((err) => this.deps.log(`cwd form failed: ${String(err)}`));
+        await this.deps.api.patchCard(state.messageId, card([form, buttonRow([this.btn({ label: "Cancel", action: "panel" }, state)])])).catch((err) => this.deps.log(`cwd form failed: ${String(err)}`));
     }
     /** A panel that outlived its process is re-remembered from the event, so
-     *  the outcome lands on the card the user is looking at. */
+     *  the outcome lands on the card the user is looking at. The submit button
+     *  carries no value, so a draft's earlier picks do not survive that restart. */
     async onCwdSubmit(key, action, root) {
-        if (!this.state(key)) {
-            this.remember(key, { chatId: action.chatId, root, messageId: action.messageId, models: [] });
-        }
-        await this.startSessionIn(key, String(action.formValue?.[CWD_FIELD] ?? "").trim());
+        if (!this.state(key))
+            this.remember(key, fresh(root, action.messageId, {}));
+        await this.chooseDir(key, String(action.formValue?.[CWD_FIELD] ?? "").trim());
     }
 }

package/dist/channels/lark-render.js

@@ -4,6 +4,7 @@
 // 「卡片」, and card interactions expire after 30 days. Lark's markdown dialect
 // takes the agent's markdown near-unmodified and treats what it cannot parse as
 // literal text, so there is no translation and no escaping.
+import { cut } from "../core/reply.js";
 import { balanceFences, chunkText } from "./chunk.js";
 /** The binding limit is the card's 30KB request cap in bytes; a CJK character
  *  spends three, so 7000 chars keeps an all-CJK turn near 21KB plus scaffolding. */
@@ -29,7 +30,7 @@ export const withFooter = (body, note) => {
     const brk = LAZY_LINE.test(last) ? "\n\n" : "\n";
     return markdown(`${body}${brk}<font color='grey'>${note}</font>`);
 };
-const truncate = (label) => label.length > BUTTON_MAX ? `${label.slice(0, BUTTON_MAX - 1)}\u2026` : label;
+const truncate = (label) => cut(label, BUTTON_MAX);
 export const button = (label, value) => ({
     tag: "button",
     text: { tag: "plain_text", content: truncate(label) },

package/dist/channels/lark.js

@@ -12,7 +12,7 @@ import { awaitsTurn } from "../core/reply.js";
 import { bindHint, bindResult, picked, STALE_OPTION, STOPPED } from "./lines.js";
 import { logger } from "../log.js";
 import { Chains } from "./chains.js";
-import { parseCommand } from "./commands.js";
+import { parseCommand, settingsDraft } from "./commands.js";
 import { Dedup } from "./dedup.js";
 import { Gatekeeper } from "./gatekeeper.js";
 import { LarkApi, } from "./lark-api.js";
@@ -24,7 +24,8 @@ import { ReceiptLedger, Receipts } from "./receipts.js";
 const WORKING = "OnIt";
 // The event is already acked, so this bounds concurrency, not the backlog.
 const MAX_ACTIVE_CHATS = 16;
-const RECEIPT_STALE_MS = 30 * 60_000;
+/** Only an idle conversation ages out, so this need not cover a long turn. */
+const RECEIPT_STALE_MS = 10 * 60_000;
 const DRAIN_TIMEOUT_MS = 5000;
 const DEDUP_TTL_MS = 5 * 60_000;
 const DEDUP_MAX = 2000;
@@ -41,6 +42,8 @@ const threadOf = (msg) => msg.rootId || msg.messageId;
 export class LarkChannel {
     deps;
     id = "lark";
+    /** No `pier lark` CLI and no mention syntax out: its ids buy the prompt nothing. */
+    opaqueIds = true;
     api;
     log;
     receipts;
@@ -71,12 +74,12 @@ export class LarkChannel {
             setReaction: (_chatId, messageId, emoji) => emoji
                 ? this.api.addReaction(messageId, emoji)
                 : this.api.removeReaction(messageId, WORKING),
-        }, deps.receipts ?? new ReceiptLedger("lark"), this.log, WORKING, RECEIPT_STALE_MS);
-        if (deps.control) {
+        }, deps.receipts ?? new ReceiptLedger("lark"), this.log, WORKING, RECEIPT_STALE_MS, (conversationId) => deps.control?.working({ channelId: this.id, conversationId }) ?? false);
+        if (deps.control && deps.handoff) {
             this.panel = new LarkPanel({
                 api: this.api,
                 control: deps.control,
-                store: deps.store,
+                handoff: deps.handoff,
                 log: this.log,
             });
         }
@@ -154,10 +157,7 @@ export class LarkChannel {
             });
         }
         const text = raw.trim();
-        // Lark gives Pier no @username a command target could match, so any target
-        // means "not us".
-        const parsed = parseCommand(text);
-        const command = parsed?.target ? undefined : parsed;
+        const command = parseCommand(text);
         const root = threadOf(msg);
         const here = { channelId: this.id, conversationId: conversationId(msg.chatId, root) };
         const bindRequest = command?.name === "bind" && isDm;
@@ -178,13 +178,16 @@ export class LarkChannel {
             return this.bind(senderId, msg.messageId, command?.args ?? "");
         if (command?.name === "stop")
             return this.abortTurn(here, msg.messageId);
-        // A bare `@bot` and `/settings` are the same request.
-        if (this.panel && (command?.name === "settings" || (!text && !attachments.length && mentioned))) {
-            return this.panel.open(here, msg.chatId, root);
-        }
         // Downloading only past the gate: an unauthorized sender must not make the
         // bot pull bytes on their behalf.
         const markers = await this.saveAttachments(msg.messageId, attachments);
+        // A bare `@bot` and `/settings` are the same request; `s <text>` drafts a
+        // session, so only where this message would start one: outside any topic.
+        // The held question carries its markers, so Start sends what the user sent.
+        const question = msg.rootId ? undefined : settingsDraft(text);
+        if (this.panel && (question || command?.name === "settings" || (!text && !attachments.length && mentioned))) {
+            return this.panel.open(here, root, question && [question, ...markers].join("\n"));
+        }
         // Resolved before the mark: any await between mark() and dispatch is a
         // window in which a previous turn can settle and take this receipt with it.
         const sender = { id: senderId, name: await this.userName(senderId) };
@@ -315,7 +318,9 @@ export class LarkChannel {
             return;
         }
         if (payload.startsWith(PANEL_PREFIX)) {
-            if (!(await this.panel?.onAction(action, key, payload, root))) {
+            // Start's question: the card is the message the tap was on, so it carries the 👀.
+            const run = (text) => this.deliver(key, action, action.messageId, text, onMessage);
+            if (!(await this.panel?.onAction(action, key, payload, root, run))) {
                 this.log(`panel action ${payload} with no panel wired, dropped`);
             }
             return;
@@ -334,23 +339,21 @@ export class LarkChannel {
         }
         // A bot cannot post as the user, so the pick is echoed: otherwise the
         // topic shows an answer to a request nobody can see, with nothing to carry the eyes.
-        const sender = { id: action.operatorId, name: await this.userName(action.operatorId) };
         await this.out.retire(action.messageId);
         const echo = await this.api.replyCard(root, card([markdown(picked(label))]))
             .catch((err) => {
             this.log(`option echo failed: ${String(err)}`);
             return undefined;
         });
+        await this.deliver(key, action, echo?.messageId, label, onMessage);
+    }
+    /** A tap's text as the tapper's message; `messageId` is the message that carries the 👀. */
+    async deliver(key, action, messageId, text, onMessage) {
+        const sender = { id: action.operatorId, name: await this.userName(action.operatorId) };
         // No await between mark and dispatch — see onMessage.
-        if (echo?.messageId)
-            this.receipts.mark(key.conversationId, action.chatId, echo.messageId);
-        onMessage({
-            key,
-            senderId: action.operatorId,
-            sender,
-            text: label,
-            mode: "steer",
-        });
+        if (messageId)
+            this.receipts.mark(key.conversationId, action.chatId, messageId);
+        onMessage({ key, senderId: action.operatorId, sender, text, mode: "steer" });
     }
     /** The abort ends the turn, which reaches send() and clears the receipts. */
     async abortTurn(key, messageId) {
@@ -405,6 +408,11 @@ export class LarkChannel {
         // The turn ended either way; a 👀 left up by a failed send looks like work.
         await this.receipts.settleAfter(conversation, () => this.out.reply(root, reply), reply.meta);
     }
+    /** A web session's topic: the root is the one card Pier posts into a
+     *  chat's main flow (channels/handoff.ts). */
+    async openThread(chatId, note) {
+        return conversationId(chatId, await this.out.open(chatId, note));
+    }
     /** The 👀 goes on the note itself: the turn it triggers has no message of
      *  the user's to carry them. */
     async notify(conversation, note) {
@@ -414,7 +422,8 @@ export class LarkChannel {
             return;
         }
         const messageId = await this.out.note(root, note);
-        if (messageId && awaitsTurn(note.origin))
-            this.receipts.mark(conversation, chatId, messageId);
+        if (messageId && awaitsTurn(note.origin)) {
+            this.receipts.mark(conversation, chatId, messageId, note.at);
+        }
     }
 }

package/dist/channels/lines.js

@@ -1,4 +1,4 @@
-// What the shared control moments say — one spelling for three platforms. The
+// What the shared control moments say — one spelling for both platforms. The
 // only legitimate variation is the spelling of the bind command, so it is the parameter.
 export const bindHint = (command) => `You are not bound yet. Ask the operator for a bind code, then send ${command}.`;
 /** The name arrives escaped by the caller. */