pikiloop 0.4.0

package/dist/channels/weixin/channel.js

@@ -0,0 +1,222 @@
+/**
+ * WeChat channel transport.
+ */
+import { Channel, DEFAULT_CHANNEL_CAPABILITIES, splitText, sleep, } from '../base.js';
+import { WEIXIN_LIMITS } from '../../core/constants.js';
+import { ChannelHealth } from '../health.js';
+import { extractWeixinTextBody, markdownToWeixinPlainText, normalizeWeixinBaseUrl, WeixinMessageType, weixinGetConfig, weixinGetUpdates, weixinSendTextMessage, weixinSendTyping, } from './api.js';
+const WEIXIN_MAX_MESSAGE_LENGTH = WEIXIN_LIMITS.maxMessageLength;
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error ?? 'unknown error');
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+export class WeixinChannel extends Channel {
+    capabilities = {
+        ...DEFAULT_CHANNEL_CAPABILITIES,
+        typingIndicators: true,
+    };
+    knownChats = new Set();
+    token;
+    accountId;
+    baseUrl;
+    pollTimeout;
+    allowedChatIds;
+    messageHandlers = new Set();
+    errorHandlers = new Set();
+    logHandlers = new Set();
+    chatMeta = new Map();
+    stopping = false;
+    updateBuf = '';
+    listenAbort = null;
+    constructor(opts) {
+        super();
+        this.token = opts.token;
+        this.accountId = opts.accountId;
+        this.baseUrl = normalizeWeixinBaseUrl(opts.baseUrl);
+        this.pollTimeout = opts.pollTimeout ?? WEIXIN_LIMITS.longPollTimeout;
+        this.allowedChatIds = opts.allowedChatIds;
+    }
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+        return this;
+    }
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        return this;
+    }
+    onLog(handler) {
+        this.logHandlers.add(handler);
+        return this;
+    }
+    async connect() {
+        const shortId = this.accountId.length > 18 ? `${this.accountId.slice(0, 8)}...${this.accountId.slice(-6)}` : this.accountId;
+        this.bot = {
+            id: this.accountId,
+            username: `weixin_${shortId}`,
+            displayName: `Weixin ${shortId}`,
+        };
+        return this.bot;
+    }
+    async listen() {
+        this.stopping = false;
+        this.listenAbort = new AbortController();
+        const health = new ChannelHealth({
+            label: 'Weixin',
+            opAction: 'polling',
+            initialDelayMs: 1_000,
+            maxDelayMs: WEIXIN_LIMITS.maxRetryDelay,
+            sustainedFailureHint: 'verify weixinBaseUrl / weixinBotToken / weixinAccountId in setting.json',
+            log: (msg, level) => this.emitLog(msg, level),
+        });
+        try {
+            while (!this.stopping) {
+                try {
+                    const response = await weixinGetUpdates({
+                        baseUrl: this.baseUrl,
+                        token: this.token,
+                        getUpdatesBuf: this.updateBuf,
+                        timeoutMs: this.pollTimeout,
+                        signal: this.listenAbort.signal,
+                    });
+                    if (response.get_updates_buf !== undefined)
+                        this.updateBuf = response.get_updates_buf || '';
+                    // Errcode check BEFORE recordSuccess(): an HTTP 200 carrying a
+                    // business error code (e.g. "session timeout") must not silently
+                    // reset the exponential backoff.
+                    if ((response.ret ?? 0) !== 0 || (response.errcode ?? 0) !== 0) {
+                        throw new Error(`Weixin getupdates failed: ${response.errmsg || response.errcode || response.ret}`);
+                    }
+                    health.recordSuccess();
+                    for (const message of response.msgs || []) {
+                        await this.dispatchInboundMessage(message);
+                    }
+                }
+                catch (error) {
+                    if (this.stopping || isAbortError(error))
+                        break;
+                    await sleep(health.recordFailure(error));
+                }
+            }
+        }
+        finally {
+            this.listenAbort = null;
+        }
+    }
+    disconnect() {
+        this.stopping = true;
+        this.listenAbort?.abort();
+    }
+    async send(chatId, text, _opts) {
+        const meta = this.chatMeta.get(String(chatId));
+        if (!meta?.contextToken)
+            throw new Error('Weixin context token is missing for this chat.');
+        const plain = markdownToWeixinPlainText(text) || String(text || '').trim();
+        const chunks = splitText(plain, WEIXIN_MAX_MESSAGE_LENGTH).map(chunk => chunk.trim()).filter(Boolean);
+        let lastMessageId = null;
+        for (const chunk of chunks) {
+            await weixinSendTextMessage({
+                baseUrl: this.baseUrl,
+                token: this.token,
+                toUserId: meta.userId,
+                text: chunk,
+                contextToken: meta.contextToken,
+            });
+            lastMessageId = `wx:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 8)}`;
+        }
+        return lastMessageId;
+    }
+    async editMessage(_chatId, _msgId, _text, _opts) { }
+    async deleteMessage(_chatId, _msgId) { }
+    async sendTyping(chatId, _opts) {
+        const meta = this.chatMeta.get(String(chatId));
+        if (!meta?.contextToken || !meta.userId)
+            return;
+        let typingTicket = meta.typingTicket;
+        if (!typingTicket) {
+            const config = await weixinGetConfig({
+                baseUrl: this.baseUrl,
+                token: this.token,
+                userId: meta.userId,
+                contextToken: meta.contextToken,
+            });
+            typingTicket = String(config.typing_ticket || '').trim();
+            if (!typingTicket)
+                return;
+            meta.typingTicket = typingTicket;
+            this.chatMeta.set(String(chatId), meta);
+        }
+        await weixinSendTyping({
+            baseUrl: this.baseUrl,
+            token: this.token,
+            userId: meta.userId,
+            typingTicket,
+        });
+    }
+    composeChatId(userId) {
+        return `${this.accountId}:${userId}`;
+    }
+    isAllowed(chatId, userId) {
+        if (!this.allowedChatIds?.size)
+            return true;
+        return this.allowedChatIds.has(chatId) || this.allowedChatIds.has(userId);
+    }
+    async dispatchInboundMessage(message) {
+        if ((message.message_type ?? WeixinMessageType.USER) !== WeixinMessageType.USER)
+            return;
+        const userId = String(message.from_user_id || '').trim();
+        if (!userId)
+            return;
+        const chatId = this.composeChatId(userId);
+        if (!this.isAllowed(chatId, userId))
+            return;
+        const existing = this.chatMeta.get(chatId);
+        const contextToken = String(message.context_token || existing?.contextToken || '').trim();
+        const meta = {
+            userId,
+            contextToken,
+            typingTicket: existing?.contextToken === contextToken ? existing?.typingTicket : undefined,
+        };
+        this.chatMeta.set(chatId, meta);
+        this.knownChats.add(chatId);
+        const ctx = {
+            chatId,
+            messageId: String(message.message_id || message.seq || Date.now()),
+            from: { userId },
+            reply: (text, opts) => this.send(chatId, text, opts),
+            editReply: (msgId, text, opts) => this.editMessage(chatId, msgId, text, opts),
+            sendTyping: () => this.sendTyping(chatId),
+            channel: this,
+            raw: message,
+        };
+        const payload = {
+            text: extractWeixinTextBody(message),
+            files: [],
+        };
+        for (const handler of this.messageHandlers) {
+            try {
+                await handler(payload, ctx);
+            }
+            catch (error) {
+                this.emitError(error instanceof Error ? error : new Error(describeError(error)));
+            }
+        }
+    }
+    emitError(error) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error);
+            }
+            catch { }
+        }
+    }
+    emitLog(msg, level) {
+        for (const handler of this.logHandlers) {
+            try {
+                handler(msg, level);
+            }
+            catch { }
+        }
+    }
+}

package/dist/cli/autostart.js

@@ -0,0 +1,262 @@
+/**
+ * macOS LaunchAgent integration for `pikiloop --daemon`.
+ *
+ * Every time the user runs pikiloop with an explicit `--daemon` flag on
+ * macOS *without* a LaunchAgent already installed, an osascript dialog asks
+ * whether to enable login auto-start. Choosing Enable writes
+ * `~/Library/LaunchAgents/ai.pikiloop.gateway.plist` and loads it via
+ * `launchctl bootstrap`. There is intentionally no CLI to disable: the user
+ * toggles it off under System Settings → General → Login Items, which is
+ * where macOS surfaces every LaunchAgent installed in
+ * `~/Library/LaunchAgents`.
+ *
+ * Decision flow (`maybePromptAutostart`):
+ *   1. Non-darwin → no-op.
+ *   2. Already running under launchd (PIKILOOP_FROM_LAUNCHD set) → no-op.
+ *   3. plist exists but its ProgramArguments no longer point to a valid
+ *      binary (e.g. Homebrew migration moved node) → silently rewrite.
+ *   4. plist already valid → no-op.
+ *   5. Non-interactive (no TTY, CI=1) → no-op.
+ *   6. Otherwise → show dialog after a short delay so the bot is already
+ *      live when the user sees it. "Not now" silently dismisses; the next
+ *      `--daemon` run will ask again.
+ */
+import { exec, execFile } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { whichSync } from '../core/platform.js';
+import { STATE_DIR_NAME } from '../core/constants.js';
+const execFileAsync = promisify(execFile);
+const PLIST_LABEL = 'ai.pikiloop.gateway';
+const PLIST_DIR = path.join(os.homedir(), 'Library', 'LaunchAgents');
+const PLIST_PATH = path.join(PLIST_DIR, `${PLIST_LABEL}.plist`);
+const PIKILOOP_HOME = path.join(os.homedir(), STATE_DIR_NAME);
+// Pre-rename LaunchAgent — removed on (re)install so an upgraded machine never
+// runs two daemons (old pikiclaw + new pikiloop). Delete post-rename.
+const LEGACY_PLIST_LABEL = 'ai.pikiclaw.gateway';
+const LEGACY_PLIST_PATH = path.join(PLIST_DIR, `${LEGACY_PLIST_LABEL}.plist`);
+const PROMPT_DELAY_MS = 3000;
+export const FROM_LAUNCHD_ENV = 'PIKILOOP_FROM_LAUNCHD';
+/**
+ * Resolve the command used to launch pikiloop, so the plist can re-launch it
+ * the same way. We distinguish npx (`.../_npx/<hash>/.../main.js`) from a
+ * globally installed binary (`pikiloop` on PATH).
+ */
+function detectInvocation() {
+    const entry = process.argv[1] || '';
+    const userArgs = process.argv.slice(2);
+    if (!userArgs.includes('--daemon'))
+        userArgs.push('--daemon');
+    if (entry.includes('/_npx/') || entry.includes('\\_npx\\')) {
+        const npxBin = whichSync('npx');
+        if (!npxBin)
+            return null;
+        return { program: npxBin, args: ['-y', 'pikiloop@latest', ...userArgs] };
+    }
+    const pikiloopBin = whichSync('pikiloop');
+    if (pikiloopBin)
+        return { program: pikiloopBin, args: userArgs };
+    return null;
+}
+function plistExists() {
+    try {
+        return fs.statSync(PLIST_PATH).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isInteractive() {
+    if (process.env.CI)
+        return false;
+    if (process.env[FROM_LAUNCHD_ENV])
+        return false;
+    return Boolean(process.stdout.isTTY || process.stderr.isTTY);
+}
+function escapeXml(s) {
+    return s.replace(/[<>&"']/g, c => ({
+        '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;', "'": '&apos;',
+    }[c]));
+}
+function buildPlistXml(invocation) {
+    const programArgs = [invocation.program, ...invocation.args]
+        .map(arg => `    <string>${escapeXml(arg)}</string>`)
+        .join('\n');
+    const stdoutPath = path.join(PIKILOOP_HOME, 'launchd-stdout.log');
+    const stderrPath = path.join(PIKILOOP_HOME, 'launchd-stderr.log');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArgs}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>${FROM_LAUNCHD_ENV}</key>
+    <string>1</string>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(stdoutPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(stderrPath)}</string>
+</dict>
+</plist>
+`;
+}
+function plistIsStale(invocation) {
+    try {
+        const xml = fs.readFileSync(PLIST_PATH, 'utf-8');
+        return !xml.includes(`<string>${escapeXml(invocation.program)}</string>`);
+    }
+    catch {
+        return false;
+    }
+}
+async function showEnableDialog() {
+    const script = [
+        'display dialog ',
+        '"Start pikiloop automatically when you log in?\\n\\n',
+        'You can change this anytime in:\\n',
+        'System Settings → General → Login Items" ',
+        'buttons {"Not now", "Enable"} default button "Enable" ',
+        'with title "pikiloop" with icon note',
+    ].join('');
+    try {
+        const { stdout } = await execFileAsync('osascript', ['-e', script]);
+        if (stdout.includes('Enable'))
+            return 'enable';
+        if (stdout.includes('Not now'))
+            return 'not_now';
+        return 'closed';
+    }
+    catch {
+        // User pressed Cmd-. or closed the dialog — osascript exits non-zero.
+        return 'closed';
+    }
+}
+async function bootstrapLaunchAgent(log) {
+    const uid = process.getuid?.() ?? 0;
+    const domain = `gui/${uid}`;
+    // bootout first so a reinstall replaces any previously-loaded copy. We
+    // swallow errors here since bootout fails harmlessly when nothing is loaded.
+    await new Promise(resolve => {
+        exec(`launchctl bootout ${domain}/${PLIST_LABEL}`, () => resolve());
+    });
+    try {
+        await execFileAsync('launchctl', ['bootstrap', domain, PLIST_PATH]);
+        return true;
+    }
+    catch (err) {
+        log(`autostart: launchctl bootstrap failed: ${err?.message || err}`);
+        return false;
+    }
+}
+/**
+ * Remove the pre-rename `ai.pikiclaw.gateway` LaunchAgent if present, so an
+ * upgraded install never runs two daemons (old pikiclaw + new pikiloop).
+ * Best-effort; safe when nothing is loaded. Delete a couple releases post-rename.
+ */
+async function cleanupLegacyAutostart(log) {
+    try {
+        let existed = false;
+        try {
+            existed = fs.statSync(LEGACY_PLIST_PATH).isFile();
+        }
+        catch { }
+        const uid = process.getuid?.() ?? 0;
+        await new Promise(resolve => {
+            exec(`launchctl bootout gui/${uid}/${LEGACY_PLIST_LABEL}`, () => resolve());
+        });
+        if (existed) {
+            try {
+                fs.unlinkSync(LEGACY_PLIST_PATH);
+            }
+            catch { }
+            log(`autostart: removed legacy LaunchAgent ${LEGACY_PLIST_LABEL}`);
+        }
+    }
+    catch { /* best-effort */ }
+}
+async function installAutostart(log, invocation) {
+    try {
+        fs.mkdirSync(PLIST_DIR, { recursive: true });
+        fs.mkdirSync(PIKILOOP_HOME, { recursive: true });
+        fs.writeFileSync(PLIST_PATH, buildPlistXml(invocation));
+    }
+    catch (err) {
+        log(`autostart: failed to write plist: ${err?.message || err}`);
+        return false;
+    }
+    const loaded = await bootstrapLaunchAgent(log);
+    if (loaded) {
+        log(`autostart: installed LaunchAgent at ${PLIST_PATH}`);
+        await cleanupLegacyAutostart(log);
+    }
+    return loaded;
+}
+/**
+ * Top-level entry called once from the watchdog process when the user passed
+ * an explicit `--daemon` flag. Fires and forgets; never throws.
+ */
+export function maybePromptAutostart(log) {
+    if (process.platform !== 'darwin')
+        return;
+    if (process.env[FROM_LAUNCHD_ENV])
+        return;
+    const invocation = detectInvocation();
+    if (!invocation)
+        return;
+    if (plistExists()) {
+        if (plistIsStale(invocation)) {
+            void installAutostart(msg => log(`autostart (rewrite): ${msg}`), invocation);
+        }
+        return;
+    }
+    if (!isInteractive())
+        return;
+    setTimeout(() => {
+        void (async () => {
+            try {
+                const choice = await showEnableDialog();
+                if (choice === 'enable') {
+                    await installAutostart(log, invocation);
+                }
+                else {
+                    log('autostart: not enabled this run; will ask again next time `pikiloop --daemon` runs');
+                }
+            }
+            catch (err) {
+                log(`autostart: prompt failed: ${err?.message || err}`);
+            }
+        })();
+    }, PROMPT_DELAY_MS).unref?.();
+}
+// ─── exports for tests ─────────────────────────────────────────────────
+export const __test = {
+    PLIST_LABEL,
+    PLIST_PATH,
+    LEGACY_PLIST_LABEL,
+    LEGACY_PLIST_PATH,
+    detectInvocation,
+    buildPlistXml,
+    plistIsStale,
+    escapeXml,
+    cleanupLegacyAutostart,
+};