charness 0.0.0-stage → 3.1.0

package/dist/utils/autoContinueOnLimit.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * @description Pure resolver for the `/auto_continue_limits` toggle — whether the bot may
+ * wait out a provider USAGE/SESSION limit and resume the topic by itself once the
+ * window resets.
+ *
+ * Scope is deliberately narrow: it gates ONLY the `usageLimit` error class. The
+ * short transient retries (rate-limited / overloaded, 5·10·20 min) stay
+ * unconditional — nobody wants to hand-restart after a 30-second hiccup — and an
+ * `auth` error is surfaced, never retried, so neither class consults this.
+ *
+ * Kept out of `bot.ts` (which cannot be imported by tests — its module-scope
+ * `parseEnv()` exits without a bot token), mirroring `resolveCompactOnIdleEnabled`
+ * in `compactOnIdle.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipArmedRetryCallbackPrefix = void 0;
+exports.resolveAutoContinueOnLimitEnabled = resolveAutoContinueOnLimitEnabled;
+exports.resolveClaudeAutoSwitchOnLimitEnabled = resolveClaudeAutoSwitchOnLimitEnabled;
+exports.buildSkipArmedRetryCallbackData = buildSkipArmedRetryCallbackData;
+exports.parseSkipArmedRetryCallbackData = parseSkipArmedRetryCallbackData;
+exports.getArmedRetrySkipDecision = getArmedRetrySkipDecision;
+const threadToggle_1 = require("./threadToggle");
+/**
+ * @description Resolve whether limit auto-continue is enabled for a thread. A
+ * per-thread override always wins; otherwise the instance-wide default applies,
+ * which is ON when unset — the feature predates the toggle and was
+ * unconditional, so ON is the behaviour-preserving default.
+ */
+function resolveAutoContinueOnLimitEnabled(globalDefault, threadOverride) {
+    return (0, threadToggle_1.resolveDefaultOnThreadToggle)(globalDefault, threadOverride);
+}
+/**
+ * @description Resolve whether the bot may switch a limited topic to ANOTHER Claude account profile by itself
+ * (`/account` → auto-switch; the decisions live in `claudeLimitSwitch.ts`, which re-exports this). A per-thread
+ * override wins; otherwise the instance default; unset everywhere ⇒ OFF — moving work between subscriptions is
+ * an account-policy decision the operator opts into. Kept beside its sibling so `state.ts` loads no more than it did.
+ */
+function resolveClaudeAutoSwitchOnLimitEnabled(globalDefault, threadOverride) {
+    return (0, threadToggle_1.resolveThreadToggle)(globalDefault, threadOverride, false);
+}
+/** `callback_data` prefix of the «skip this resume once» button. */
+exports.skipArmedRetryCallbackPrefix = 'acl_skip_';
+/**
+ * @description Build the «skip once» button's `callback_data`. The armed record's
+ * `fireAt` is BAKED IN because inline buttons stay tappable forever: without it a
+ * tap on an OLD notice would cancel whatever episode happens to be armed NOW (the
+ * same class of bug as the `/disconnect` picker resolving a stale index against a
+ * fresh provider list). Prefix + a 13-digit epoch is ~22 bytes, far inside
+ * Telegram's 64-byte `callback_data` cap.
+ */
+function buildSkipArmedRetryCallbackData(fireAt) {
+    return `${exports.skipArmedRetryCallbackPrefix}${fireAt}`;
+}
+/** Inverse of {@link buildSkipArmedRetryCallbackData}; `null` for foreign data. */
+function parseSkipArmedRetryCallbackData(data) {
+    if (!data.startsWith(exports.skipArmedRetryCallbackPrefix))
+        return null;
+    const raw = data.slice(exports.skipArmedRetryCallbackPrefix.length);
+    if (!/^\d+$/.test(raw))
+        return null;
+    return Number(raw);
+}
+/**
+ * @description What a «skip once» tap should do: `skip` only when the thread still
+ * has that EXACT armed resume pending, `expired` when nothing is armed any more or
+ * a DIFFERENT episode is (the notice the user tapped is stale). `expired` must
+ * change no state — silently skipping the newer episode would cancel a resume the
+ * user never asked to cancel.
+ *
+ * @param armedFireAt `fireAt` of the thread's currently pending limit resume, or
+ *   `null` when none is armed.
+ */
+function getArmedRetrySkipDecision(input) {
+    if (input.armedFireAt === null)
+        return 'expired';
+    return input.armedFireAt === input.requestedFireAt ? 'skip' : 'expired';
+}
+//# sourceMappingURL=autoContinueOnLimit.js.map

package/dist/utils/autoContinueOnLimit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoContinueOnLimit.js","sourceRoot":"","sources":["../../src/utils/autoContinueOnLimit.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAUH,8EAKC;AAQD,sFAKC;AAaD,0EAEC;AAGD,0EAKC;AAYD,8DAMC;AAnED,iDAAmF;AAEnF;;;;;GAKG;AACH,SAAgB,iCAAiC,CAC/C,aAAkC,EAClC,cAAmC;IAEnC,OAAO,IAAA,2CAA4B,EAAC,aAAa,EAAE,cAAc,CAAC,CAAC;AACrE,CAAC;AAED;;;;;GAKG;AACH,SAAgB,qCAAqC,CACnD,aAAkC,EAClC,cAAmC;IAEnC,OAAO,IAAA,kCAAmB,EAAC,aAAa,EAAE,cAAc,EAAE,KAAK,CAAC,CAAC;AACnE,CAAC;AAED,oEAAoE;AACvD,QAAA,4BAA4B,GAAG,WAAW,CAAC;AAExD;;;;;;;GAOG;AACH,SAAgB,+BAA+B,CAAC,MAAc;IAC5D,OAAO,GAAG,oCAA4B,GAAG,MAAM,EAAE,CAAC;AACpD,CAAC;AAED,mFAAmF;AACnF,SAAgB,+BAA+B,CAAC,IAAY;IAC1D,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,oCAA4B,CAAC;QAAE,OAAO,IAAI,CAAC;IAChE,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,oCAA4B,CAAC,MAAM,CAAC,CAAC;IAC5D,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACpC,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;AACrB,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,yBAAyB,CAAC,KAGzC;IACC,IAAI,KAAK,CAAC,WAAW,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IACjD,OAAO,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AAC1E,CAAC"}

package/dist/utils/canonicalPathContainment.d.ts

@@ -0,0 +1,7 @@
+export interface CanonicalPathContainment {
+    canonicalPath: string;
+    isWithinRoot: boolean;
+}
+/** Resolve one candidate against a canonical root and compare with a separator-safe boundary. */
+export declare function resolveCanonicalPathContainment(canonicalRootPath: string, relativePath: string): CanonicalPathContainment;
+//# sourceMappingURL=canonicalPathContainment.d.ts.map

package/dist/utils/canonicalPathContainment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalPathContainment.d.ts","sourceRoot":"","sources":["../../src/utils/canonicalPathContainment.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,iGAAiG;AACjG,wBAAgB,+BAA+B,CAC7C,iBAAiB,EAAE,MAAM,EACzB,YAAY,EAAE,MAAM,GACnB,wBAAwB,CAQ1B"}

package/dist/utils/canonicalPathContainment.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCanonicalPathContainment = resolveCanonicalPathContainment;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Resolve one candidate against a canonical root and compare with a separator-safe boundary. */
+function resolveCanonicalPathContainment(canonicalRootPath, relativePath) {
+    const canonicalPath = fs.realpathSync(path.resolve(canonicalRootPath, relativePath));
+    return {
+        canonicalPath,
+        isWithinRoot: canonicalPath === canonicalRootPath ||
+            canonicalPath.startsWith(canonicalRootPath + path.sep),
+    };
+}
+//# sourceMappingURL=canonicalPathContainment.js.map

package/dist/utils/canonicalPathContainment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalPathContainment.js","sourceRoot":"","sources":["../../src/utils/canonicalPathContainment.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,0EAWC;AApBD,uCAAyB;AACzB,2CAA6B;AAO7B,iGAAiG;AACjG,SAAgB,+BAA+B,CAC7C,iBAAyB,EACzB,YAAoB;IAEpB,MAAM,aAAa,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC,CAAC;IACrF,OAAO;QACL,aAAa;QACb,YAAY,EACV,aAAa,KAAK,iBAAiB;YACnC,aAAa,CAAC,UAAU,CAAC,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC;KACzD,CAAC;AACJ,CAAC"}

package/dist/utils/claudeAccountPickerPlan.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @description Pure plan of the `/account` picker (`connectors/telegram/commands/claudeAccounts.ts`): the
+ * `callback_data` codecs and the per-profile row model. Profile names are slugs of at most 32 characters
+ * (`utils/claudeProfiles.ts`), so a button BAKES THE NAME into its data (`acct_use_<name>` is at most 41
+ * bytes, under Telegram's 64-byte cap) and an old keyboard can never act on a profile other than the one it
+ * named — a removed name simply resolves to "unknown profile".
+ */
+import type { ClaudeProfileRecord } from '../state';
+import { type ClaudeAccountKind } from './claudeProfiles';
+/** Switch the topic (General: the instance default) to the named profile. */
+export declare const accountUseCallbackRe: RegExp;
+/** Open the sub-picker that chooses a profile to sign in again / to remove. */
+export declare const accountLoginMenuCallback = "acct_login_menu";
+export declare const accountRemoveMenuCallback = "acct_rm_menu";
+/** Start the sign-in of the named profile. */
+export declare const accountLoginCallbackRe: RegExp;
+/** Ask to confirm the removal of the named profile, then remove it. */
+export declare const accountRemoveCallbackRe: RegExp;
+export declare const accountRemoveConfirmCallbackRe: RegExp;
+/** Ask for a new profile's name. */
+export declare const accountAddCallback = "acct_add";
+/** A topic drops its own pick and follows the instance default again. */
+export declare const accountFollowDefaultCallback = "acct_follow";
+/** Arm the OpenCode provider-id capture (the next plain message names the provider to connect). */
+export declare const accountAddProviderCallback = "acct_ocadd";
+/**
+ * Disconnect an OpenCode provider: the INDEX points into the provider list the screen listed, snapshotted per
+ * message (a provider id can be long and the list changes), then the confirmation of the same index.
+ */
+export declare const accountDisconnectCallbackRe: RegExp;
+export declare const accountDisconnectConfirmCallbackRe: RegExp;
+/** Connect an OpenCode provider again (the `/connect <provider>` method picker); same snapshot index. */
+export declare const accountReconnectCallbackRe: RegExp;
+/** Back to the main picker from a sub-picker. */
+export declare const accountBackCallback = "acct_back";
+/** Flip the auto-switch-on-limit setting (`utils/claudeLimitSwitch.ts`): the topic's override, in General the instance default. */
+export declare const accountAutoSwitchOnCallback = "acct_autosw_on";
+export declare const accountAutoSwitchOffCallback = "acct_autosw_off";
+export declare function buildAccountUseCallback(name: string): string;
+export declare function buildAccountLoginCallback(name: string): string;
+export declare function buildAccountDisconnectCallback(index: number): string;
+export declare function buildAccountReconnectCallback(index: number): string;
+export declare function buildAccountDisconnectConfirmCallback(index: number): string;
+export declare function buildAccountRemoveCallback(name: string): string;
+export declare function buildAccountRemoveConfirmCallback(name: string): string;
+/**
+ * @description The name a callback's data carries, or `null` when the data is not that button's or names an
+ * impossible profile (`default` is a valid target for use / login / removal only where `allowDefault`).
+ */
+export declare function parseAccountCallbackName(data: string, re: RegExp, options: {
+    allowDefault: boolean;
+}): string | null;
+/** One line / one button of the picker. */
+export interface AccountPickerRow {
+    name: string;
+    /** The profile the topic (General: the instance) effectively uses. */
+    isActive: boolean;
+    /** The CLI's last answer; `undefined` when never read. */
+    loggedIn: boolean | undefined;
+    email: string | null;
+    subscriptionType: string | null;
+    kind: ClaudeAccountKind;
+    /** How many bound topics resolve to this profile. */
+    topicCount: number;
+}
+/**
+ * @description The picker's rows: `default` first, then the added profiles in creation order. `topicCounts`
+ * is the resolved use per profile (explicit picks AND topics that follow the instance default), so the count
+ * answers "which topics would a removal or re-login touch".
+ */
+export declare function buildAccountPickerRows(input: {
+    records: Readonly<Record<string, ClaudeProfileRecord>>;
+    defaultStatus: {
+        loggedIn: boolean | undefined;
+        email: string | null;
+        subscriptionType: string | null;
+    };
+    activeName: string;
+    topicCounts: ReadonlyMap<string, number>;
+    /** The operator removed (signed out) `default`: it has no row until it is signed in again. */
+    isDefaultRemoved?: boolean;
+}): AccountPickerRow[];
+/** The profile each bound topic resolves to, counted per profile name. */
+export declare function countTopicsPerProfile(resolvedNames: Iterable<string>): Map<string, number>;
+//# sourceMappingURL=claudeAccountPickerPlan.d.ts.map

package/dist/utils/claudeAccountPickerPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeAccountPickerPlan.d.ts","sourceRoot":"","sources":["../../src/utils/claudeAccountPickerPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AAI1B,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,QAAwC,CAAC;AAC1E,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB,oBAAoB,CAAC;AAC1D,eAAO,MAAM,yBAAyB,iBAAiB,CAAC;AACxD,8CAA8C;AAC9C,eAAO,MAAM,sBAAsB,QAA0C,CAAC;AAC9E,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,QAAuC,CAAC;AAC5E,eAAO,MAAM,8BAA8B,QAAyC,CAAC;AACrF,oCAAoC;AACpC,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAC7C,yEAAyE;AACzE,eAAO,MAAM,4BAA4B,gBAAgB,CAAC;AAC1D,mGAAmG;AACnG,eAAO,MAAM,0BAA0B,eAAe,CAAC;AACvD;;;GAGG;AACH,eAAO,MAAM,2BAA2B,QAAwB,CAAC;AACjE,eAAO,MAAM,kCAAkC,QAA0B,CAAC;AAC1E,yGAAyG;AACzG,eAAO,MAAM,0BAA0B,QAA0B,CAAC;AAClE,iDAAiD;AACjD,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAC/C,mIAAmI;AACnI,eAAO,MAAM,2BAA2B,mBAAmB,CAAC;AAC5D,eAAO,MAAM,4BAA4B,oBAAoB,CAAC;AAE9D,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,wBAAgB,qCAAqC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE;IAAE,YAAY,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAMpH;AAED,2CAA2C;AAC3C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,QAAQ,EAAE,OAAO,CAAC;IAClB,0DAA0D;IAC1D,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,IAAI,EAAE,iBAAiB,CAAC;IACxB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;IACvD,aAAa,EAAE;QAAE,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACxG,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,8FAA8F;IAC9F,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,gBAAgB,EAAE,CAwBrB;AAED,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAI1F"}

package/dist/utils/claudeAccountPickerPlan.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * @description Pure plan of the `/account` picker (`connectors/telegram/commands/claudeAccounts.ts`): the
+ * `callback_data` codecs and the per-profile row model. Profile names are slugs of at most 32 characters
+ * (`utils/claudeProfiles.ts`), so a button BAKES THE NAME into its data (`acct_use_<name>` is at most 41
+ * bytes, under Telegram's 64-byte cap) and an old keyboard can never act on a profile other than the one it
+ * named — a removed name simply resolves to "unknown profile".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountAutoSwitchOffCallback = exports.accountAutoSwitchOnCallback = exports.accountBackCallback = exports.accountReconnectCallbackRe = exports.accountDisconnectConfirmCallbackRe = exports.accountDisconnectCallbackRe = exports.accountAddProviderCallback = exports.accountFollowDefaultCallback = exports.accountAddCallback = exports.accountRemoveConfirmCallbackRe = exports.accountRemoveCallbackRe = exports.accountLoginCallbackRe = exports.accountRemoveMenuCallback = exports.accountLoginMenuCallback = exports.accountUseCallbackRe = void 0;
+exports.buildAccountUseCallback = buildAccountUseCallback;
+exports.buildAccountLoginCallback = buildAccountLoginCallback;
+exports.buildAccountDisconnectCallback = buildAccountDisconnectCallback;
+exports.buildAccountReconnectCallback = buildAccountReconnectCallback;
+exports.buildAccountDisconnectConfirmCallback = buildAccountDisconnectConfirmCallback;
+exports.buildAccountRemoveCallback = buildAccountRemoveCallback;
+exports.buildAccountRemoveConfirmCallback = buildAccountRemoveConfirmCallback;
+exports.parseAccountCallbackName = parseAccountCallbackName;
+exports.buildAccountPickerRows = buildAccountPickerRows;
+exports.countTopicsPerProfile = countTopicsPerProfile;
+const claudeProfiles_1 = require("./claudeProfiles");
+const nameGroup = '([a-z0-9][a-z0-9_-]{0,31})';
+/** Switch the topic (General: the instance default) to the named profile. */
+exports.accountUseCallbackRe = new RegExp(`^acct_use_${nameGroup}$`);
+/** Open the sub-picker that chooses a profile to sign in again / to remove. */
+exports.accountLoginMenuCallback = 'acct_login_menu';
+exports.accountRemoveMenuCallback = 'acct_rm_menu';
+/** Start the sign-in of the named profile. */
+exports.accountLoginCallbackRe = new RegExp(`^acct_login_${nameGroup}$`);
+/** Ask to confirm the removal of the named profile, then remove it. */
+exports.accountRemoveCallbackRe = new RegExp(`^acct_rm_${nameGroup}$`);
+exports.accountRemoveConfirmCallbackRe = new RegExp(`^acct_rmok_${nameGroup}$`);
+/** Ask for a new profile's name. */
+exports.accountAddCallback = 'acct_add';
+/** A topic drops its own pick and follows the instance default again. */
+exports.accountFollowDefaultCallback = 'acct_follow';
+/** Arm the OpenCode provider-id capture (the next plain message names the provider to connect). */
+exports.accountAddProviderCallback = 'acct_ocadd';
+/**
+ * Disconnect an OpenCode provider: the INDEX points into the provider list the screen listed, snapshotted per
+ * message (a provider id can be long and the list changes), then the confirmation of the same index.
+ */
+exports.accountDisconnectCallbackRe = /^acct_dc_(\d{1,2})$/;
+exports.accountDisconnectConfirmCallbackRe = /^acct_dcok_(\d{1,2})$/;
+/** Connect an OpenCode provider again (the `/connect <provider>` method picker); same snapshot index. */
+exports.accountReconnectCallbackRe = /^acct_dcre_(\d{1,2})$/;
+/** Back to the main picker from a sub-picker. */
+exports.accountBackCallback = 'acct_back';
+/** Flip the auto-switch-on-limit setting (`utils/claudeLimitSwitch.ts`): the topic's override, in General the instance default. */
+exports.accountAutoSwitchOnCallback = 'acct_autosw_on';
+exports.accountAutoSwitchOffCallback = 'acct_autosw_off';
+function buildAccountUseCallback(name) {
+    return `acct_use_${name}`;
+}
+function buildAccountLoginCallback(name) {
+    return `acct_login_${name}`;
+}
+function buildAccountDisconnectCallback(index) {
+    return `acct_dc_${index}`;
+}
+function buildAccountReconnectCallback(index) {
+    return `acct_dcre_${index}`;
+}
+function buildAccountDisconnectConfirmCallback(index) {
+    return `acct_dcok_${index}`;
+}
+function buildAccountRemoveCallback(name) {
+    return `acct_rm_${name}`;
+}
+function buildAccountRemoveConfirmCallback(name) {
+    return `acct_rmok_${name}`;
+}
+/**
+ * @description The name a callback's data carries, or `null` when the data is not that button's or names an
+ * impossible profile (`default` is a valid target for use / login / removal only where `allowDefault`).
+ */
+function parseAccountCallbackName(data, re, options) {
+    const match = data.match(re);
+    if (!match)
+        return null;
+    const name = match[1];
+    if (name === claudeProfiles_1.defaultClaudeProfileName)
+        return options.allowDefault ? name : null;
+    return (0, claudeProfiles_1.checkIsValidClaudeProfileName)(name) ? name : null;
+}
+/**
+ * @description The picker's rows: `default` first, then the added profiles in creation order. `topicCounts`
+ * is the resolved use per profile (explicit picks AND topics that follow the instance default), so the count
+ * answers "which topics would a removal or re-login touch".
+ */
+function buildAccountPickerRows(input) {
+    const rows = input.isDefaultRemoved ? [] : [{
+            name: claudeProfiles_1.defaultClaudeProfileName,
+            isActive: input.activeName === claudeProfiles_1.defaultClaudeProfileName,
+            loggedIn: input.defaultStatus.loggedIn,
+            email: input.defaultStatus.email,
+            subscriptionType: input.defaultStatus.subscriptionType,
+            kind: (0, claudeProfiles_1.getClaudeAccountKind)(input.defaultStatus.subscriptionType),
+            topicCount: input.topicCounts.get(claudeProfiles_1.defaultClaudeProfileName) ?? 0,
+        }];
+    const added = Object.entries(input.records)
+        .sort(([, a], [, b]) => a.createdAt.localeCompare(b.createdAt));
+    for (const [name, record] of added) {
+        rows.push({
+            name,
+            isActive: input.activeName === name,
+            loggedIn: record.loggedIn,
+            email: record.email ?? null,
+            subscriptionType: record.subscriptionType ?? null,
+            kind: (0, claudeProfiles_1.getClaudeAccountKind)(record.subscriptionType ?? null),
+            topicCount: input.topicCounts.get(name) ?? 0,
+        });
+    }
+    return rows;
+}
+/** The profile each bound topic resolves to, counted per profile name. */
+function countTopicsPerProfile(resolvedNames) {
+    const counts = new Map();
+    for (const name of resolvedNames)
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    return counts;
+}
+//# sourceMappingURL=claudeAccountPickerPlan.js.map

package/dist/utils/claudeAccountPickerPlan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeAccountPickerPlan.js","sourceRoot":"","sources":["../../src/utils/claudeAccountPickerPlan.ts"],"names":[],"mappings":"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"}

package/dist/utils/claudeAuthLogin.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @description Pure helpers behind the json-stream `/login` out-of-band auth
+ * flow. The json-stream Claude backend has no TUI to host Claude's interactive
+ * `/login`, so the bot drives `claude auth login --claudeai` in a pty and relays
+ * it through the topic (URL out -> pasted code in). These are the parse/decision
+ * helpers; the impure pty driving + per-thread state live in `agentLogin/agentLogin.ts`
+ * (mirrors the `apiErrorRetry.ts` pure-layer / manager split).
+ *
+ * The success signal is authoritative from `claude auth status --json`
+ * (`{"loggedIn": true, ...}`), with the process exit code as the fallback.
+ */
+/**
+ * @description The load-bearing marker line of Claude's `/login` OAuth
+ * "paste the code" step (`Paste code here if prompted > `). Shared with the
+ * tmux-scrape backend's login-paste detection so the marker string has a single
+ * definition.
+ */
+export declare const claudeLoginPastePromptRe: RegExp;
+/**
+ * @description First `http(s)` URL in `claude auth login`'s pty output — the
+ * OAuth sign-in link. The CLI prints it inside an OSC-8 hyperlink
+ * (`ESC]8;;<url>BEL`) and again as visible blue text; the match stops at the
+ * first whitespace / C0 control char (the BEL that terminates the OSC-8 target),
+ * so the captured URL is already clean of ANSI. Returns `null` if none yet.
+ */
+export declare function parseClaudeAuthLoginUrl(ptyOutput: string): string | null;
+/**
+ * @description Whether the accumulated pty output has reached the "paste the
+ * code" prompt — i.e. the CLI has printed the sign-in URL and is now waiting for
+ * the code. Used to gate the URL relay so a URL split across pty chunks is never
+ * relayed half-rendered.
+ */
+export declare function checkIsClaudeAuthLoginCodePrompt(ptyOutput: string): boolean;
+/**
+ * @description Read `loggedIn` out of `claude auth status --json`. Returns the
+ * boolean, or `null` when the JSON is missing/malformed or lacks the field.
+ */
+export declare function parseAuthStatusLoggedIn(statusJson: string): boolean | null;
+/**
+ * @description Decide whether the login succeeded. `claude auth status` is
+ * authoritative (it reflects the real on-disk credentials after the flow); the
+ * process exit code is only the fallback when the status probe could not be read
+ * (`loggedIn === null`).
+ */
+export declare function checkIsAuthLoginSucceeded(input: {
+    exitCode: number | null;
+    loggedIn: boolean | null;
+}): boolean;
+/** How a `/login` slash command is handled for a thread. */
+export type LoginCommandRoute = 'outOfBand' | 'forwardToAgent';
+/**
+ * @description Route a `/login` command by the thread's Claude backend. Only the
+ * json-stream backends (`claude-json-stream` and `claude-per-turn` — one host,
+ * no TUI to host the OAuth flow) intercept it into the bot-driven out-of-band
+ * flow; every other case — tmux-scrape Claude
+ * (its TUI hosts `/login` itself), OpenCode/terminal, or a no-pick thread — keeps
+ * the existing verbatim forward.
+ *
+ * The backend is read from the thread's RAW adapter pick, NOT a "resolve to the
+ * Claude default" call: an OpenCode/terminal thread has a non-Claude raw pick, so
+ * gating on the raw name avoids wrongly intercepting `/login` on those threads
+ * (which a default-resolving check would do once json-stream is the default).
+ * `checkIsJsonStreamBackend` is injected to keep this helper free of an adapter
+ * import.
+ */
+export declare function getLoginCommandRoute(input: {
+    command: string;
+    rawBackendName: string | undefined;
+    checkIsJsonStreamBackend: (adapterName: string) => boolean;
+}): LoginCommandRoute;
+//# sourceMappingURL=claudeAuthLogin.d.ts.map

package/dist/utils/claudeAuthLogin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeAuthLogin.d.ts","sourceRoot":"","sources":["../../src/utils/claudeAuthLogin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,QAAgC,CAAC;AAKtE;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGxE;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE3E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAO1E;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;CAC1B,GAAG,OAAO,CAGV;AAED,4DAA4D;AAC5D,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAE/D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,wBAAwB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5D,GAAG,iBAAiB,CAIpB"}

package/dist/utils/claudeAuthLogin.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * @description Pure helpers behind the json-stream `/login` out-of-band auth
+ * flow. The json-stream Claude backend has no TUI to host Claude's interactive
+ * `/login`, so the bot drives `claude auth login --claudeai` in a pty and relays
+ * it through the topic (URL out -> pasted code in). These are the parse/decision
+ * helpers; the impure pty driving + per-thread state live in `agentLogin/agentLogin.ts`
+ * (mirrors the `apiErrorRetry.ts` pure-layer / manager split).
+ *
+ * The success signal is authoritative from `claude auth status --json`
+ * (`{"loggedIn": true, ...}`), with the process exit code as the fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeLoginPastePromptRe = void 0;
+exports.parseClaudeAuthLoginUrl = parseClaudeAuthLoginUrl;
+exports.checkIsClaudeAuthLoginCodePrompt = checkIsClaudeAuthLoginCodePrompt;
+exports.parseAuthStatusLoggedIn = parseAuthStatusLoggedIn;
+exports.checkIsAuthLoginSucceeded = checkIsAuthLoginSucceeded;
+exports.getLoginCommandRoute = getLoginCommandRoute;
+/**
+ * @description The load-bearing marker line of Claude's `/login` OAuth
+ * "paste the code" step (`Paste code here if prompted > `). Shared with the
+ * tmux-scrape backend's login-paste detection so the marker string has a single
+ * definition.
+ */
+exports.claudeLoginPastePromptRe = /Paste code here if prompted/;
+/** Matches the first http(s) URL, stopping at whitespace or any C0 control char. */
+const oauthLoginUrlRe = /https?:\/\/[^\s\u0000-\u001f]+/;
+/**
+ * @description First `http(s)` URL in `claude auth login`'s pty output — the
+ * OAuth sign-in link. The CLI prints it inside an OSC-8 hyperlink
+ * (`ESC]8;;<url>BEL`) and again as visible blue text; the match stops at the
+ * first whitespace / C0 control char (the BEL that terminates the OSC-8 target),
+ * so the captured URL is already clean of ANSI. Returns `null` if none yet.
+ */
+function parseClaudeAuthLoginUrl(ptyOutput) {
+    const match = ptyOutput.match(oauthLoginUrlRe);
+    return match ? match[0] : null;
+}
+/**
+ * @description Whether the accumulated pty output has reached the "paste the
+ * code" prompt — i.e. the CLI has printed the sign-in URL and is now waiting for
+ * the code. Used to gate the URL relay so a URL split across pty chunks is never
+ * relayed half-rendered.
+ */
+function checkIsClaudeAuthLoginCodePrompt(ptyOutput) {
+    return exports.claudeLoginPastePromptRe.test(ptyOutput);
+}
+/**
+ * @description Read `loggedIn` out of `claude auth status --json`. Returns the
+ * boolean, or `null` when the JSON is missing/malformed or lacks the field.
+ */
+function parseAuthStatusLoggedIn(statusJson) {
+    try {
+        const parsed = JSON.parse(statusJson);
+        return typeof parsed.loggedIn === 'boolean' ? parsed.loggedIn : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * @description Decide whether the login succeeded. `claude auth status` is
+ * authoritative (it reflects the real on-disk credentials after the flow); the
+ * process exit code is only the fallback when the status probe could not be read
+ * (`loggedIn === null`).
+ */
+function checkIsAuthLoginSucceeded(input) {
+    if (input.loggedIn !== null)
+        return input.loggedIn;
+    return input.exitCode === 0;
+}
+/**
+ * @description Route a `/login` command by the thread's Claude backend. Only the
+ * json-stream backends (`claude-json-stream` and `claude-per-turn` — one host,
+ * no TUI to host the OAuth flow) intercept it into the bot-driven out-of-band
+ * flow; every other case — tmux-scrape Claude
+ * (its TUI hosts `/login` itself), OpenCode/terminal, or a no-pick thread — keeps
+ * the existing verbatim forward.
+ *
+ * The backend is read from the thread's RAW adapter pick, NOT a "resolve to the
+ * Claude default" call: an OpenCode/terminal thread has a non-Claude raw pick, so
+ * gating on the raw name avoids wrongly intercepting `/login` on those threads
+ * (which a default-resolving check would do once json-stream is the default).
+ * `checkIsJsonStreamBackend` is injected to keep this helper free of an adapter
+ * import.
+ */
+function getLoginCommandRoute(input) {
+    return input.command === 'login' && input.rawBackendName !== undefined && input.checkIsJsonStreamBackend(input.rawBackendName)
+        ? 'outOfBand'
+        : 'forwardToAgent';
+}
+//# sourceMappingURL=claudeAuthLogin.js.map

package/dist/utils/claudeAuthLogin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeAuthLogin.js","sourceRoot":"","sources":["../../src/utils/claudeAuthLogin.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAoBH,0DAGC;AAQD,4EAEC;AAMD,0DAOC;AAQD,8DAMC;AAoBD,oDAQC;AAtFD;;;;;GAKG;AACU,QAAA,wBAAwB,GAAG,6BAA6B,CAAC;AAEtE,oFAAoF;AACpF,MAAM,eAAe,GAAG,gCAAgC,CAAC;AAEzD;;;;;;GAMG;AACH,SAAgB,uBAAuB,CAAC,SAAiB;IACvD,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IAC/C,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,SAAgB,gCAAgC,CAAC,SAAiB;IAChE,OAAO,gCAAwB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAClD,CAAC;AAED;;;GAGG;AACH,SAAgB,uBAAuB,CAAC,UAAkB;IACxD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAA2B,CAAC;QAChE,OAAO,OAAO,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;IACvE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAgB,yBAAyB,CAAC,KAGzC;IACC,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC,QAAQ,CAAC;IACnD,OAAO,KAAK,CAAC,QAAQ,KAAK,CAAC,CAAC;AAC9B,CAAC;AAKD;;;;;;;;;;;;;;GAcG;AACH,SAAgB,oBAAoB,CAAC,KAIpC;IACC,OAAO,KAAK,CAAC,OAAO,KAAK,OAAO,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,IAAI,KAAK,CAAC,wBAAwB,CAAC,KAAK,CAAC,cAAc,CAAC;QAC5H,CAAC,CAAC,WAAW;QACb,CAAC,CAAC,gBAAgB,CAAC;AACvB,CAAC"}

package/dist/utils/claudeChunkClassifier.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @description PURE classifier that segments a scraped, ANSI-cleaned Claude
+ * TUI pane chunk into TAGGED spans, carrying tool-fence context across poll
+ * chunks (the same cross-poll state the relay already threads as
+ * `session.openToolKind` through {@link stripTuiElementsWithContext}).
+ *
+ * This is the decision layer for the verbosity scopes (S4 `/tool_results`, S5
+ * `/thinking`, S6 sub-agent panel fold): given a chunk it labels each run of
+ * lines so a later caller can keep / drop / re-route them per the topic's
+ * verbosity mode. S3 only BUILDS and TESTS the classifier — it is NOT wired
+ * into the live relay yet, so the relay path keeps behaving exactly as today.
+ *
+ * Design rules:
+ *  - Reuses the line-shape regexes from {@link ./claudeScrapeShapes} and the
+ *    sub-agent progress shape from {@link ../progressLine} — ONE definition per
+ *    shape, never a copy.
+ *  - Conservative default: a line not positively recognised as tool / thinking
+ *    / panel chatter / chrome is tagged {@link ClaudeChunkTag.Prose} — the
+ *    agent's real answer is never swallowed.
+ *  - Cross-poll fence semantics DERIVE FROM {@link fenceToolResultBodies} but
+ *    are not identical (this classifier serves the verbosity consumer, not the
+ *    fencer): a tool header opens a kind; a `⎿` body or its orphan indented
+ *    continuation is the tool body for that kind; a solid prose line closes the
+ *    kind. Two intentional divergences, flagged at their call sites below: a
+ *    file-kind `⎿` summary is tagged `ToolBody` (the fencer keeps it prose),
+ *    and a `◯`/`▰▱` panel line does NOT close an open kind (the fencer resets
+ *    it). A future S4 reader must not assume identical reset behavior.
+ */
+import { type ToolResultKind } from './claudeScrapeShapes';
+/**
+ * @name ClaudeChunkTag
+ * @description The classification of a run of pane lines.
+ *  - `thinkingBlock`        — "Thinking for {N}s…" / "Thought for Ns" headers,
+ *                             their reasoning body, and the post-thinking trailer.
+ *  - `toolHeader`           — a tool-call header line (`● Bash(…)`, `✓ Read(…)`).
+ *  - `toolBody`             — the `⎿` result body + its fenced/indented body.
+ *  - `subagentPanelPreview` — the tool-PREVIEW chatter the TUI draws under a
+ *                             running `◯` sub-agent panel (`⎿ Bash(…)` previews,
+ *                             "… +N tool uses" walls) — distinct from the ◯
+ *                             title line itself (progress, tagged chrome).
+ *  - `prose`                — real agent answer text (the conservative default).
+ *  - `chrome`               — TUI chrome the relay already drops (box-drawing,
+ *                             nav hints, question/survey chrome, input echo,
+ *                             installer ads, ◯ panel title, spinner ticks).
+ */
+export declare enum ClaudeChunkTag {
+    ThinkingBlock = "thinkingBlock",
+    ToolHeader = "toolHeader",
+    ToolBody = "toolBody",
+    SubagentPanelPreview = "subagentPanelPreview",
+    Prose = "prose",
+    Chrome = "chrome"
+}
+/** One classified run of consecutive same-tag lines, original order preserved. */
+export interface ClaudeChunkSegment {
+    tag: ClaudeChunkTag;
+    text: string;
+}
+/**
+ * @description Fence / block state threaded BETWEEN poll chunks — mirrors the
+ * adapter's `session.openToolKind`. A tool body, a thinking block, or a
+ * sub-agent panel can span the boundary between two scraped chunks (Claude
+ * redraws the whole pane each poll; the diff emits only NEW lines, so a slow
+ * command's output arrives in a later poll without its header).
+ */
+export interface ClaudeChunkContext {
+    /** Open tool-result kind (`output`/`file`) whose body is still streaming, or null. */
+    toolKind: ToolResultKind | null;
+    /** A "Thinking for…" block is open and its reasoning body is still streaming. */
+    isThinkingOpen: boolean;
+    /** A `◯` sub-agent panel is on screen, so its `⎿`/`Tool(…)` previews are panel chatter. */
+    isSubagentPanelOpen: boolean;
+}
+/** The all-closed starting context (also used when a fresh session begins). */
+export declare function createInitialChunkContext(): ClaudeChunkContext;
+/** Result of classifying one chunk: ordered segments + the context to thread on. */
+export interface ClaudeChunkClassification {
+    segments: ClaudeChunkSegment[];
+    outgoingContext: ClaudeChunkContext;
+}
+/**
+ * @description Classify one scraped, ANSI-cleaned chunk into tagged segments,
+ * threading {@link ClaudeChunkContext} across polls.
+ *
+ * Per-line precedence (first match wins), then adjacent same-tag lines coalesce:
+ *  1. blank line  → inherits the still-open block's tag (keeps a body contiguous)
+ *  2. code fence  → toggles an agent fence; inside it everything is prose
+ *  3. ◯ panel title / spinner tick / generic chrome → `chrome` (sets panel flag)
+ *  4. sub-agent panel preview (`⎿ Tool(…)`, indented `Tool(…)`, "+N tool uses"
+ *     while a panel is open) → `subagentPanelPreview`
+ *  5. thinking header / trailer / open-thinking body → `thinkingBlock`
+ *  6. tool header → `toolHeader` (opens the matching kind)
+ *  7. `⎿` marker / indented continuation of an open tool kind → `toolBody`
+ *  8. anything else → `prose` (closes any open tool/thinking block)
+ */
+export declare function classifyClaudeChunk(chunkText: string, incomingContext: ClaudeChunkContext): ClaudeChunkClassification;
+//# sourceMappingURL=claudeChunkClassifier.d.ts.map