@lmctl-ai/lmctl 0.1.342 → 0.2.3

package/dist/script/lmscript.d.ts

@@ -0,0 +1,550 @@
+/**
+ * LMScript - A lightweight prototype scripting language implemented in TypeScript.
+ *
+ * Requirements Met:
+ * 1. Single file: Self-contained implementation (Lexer, Parser, Static Checker, Interpreter, Host API) with zero dependencies.
+ * 2. Scan all and check before execution: In-memory AST validation upfront. Zero intermediate files generated.
+ * 3. Language features: Top-level functions, flow control (if/else, while, for, break, continue, return), tuple & destructuring assignment: (a, b) = [1, 2], dot notation (data.key), object literals { key: val }, and negative indexing arr[-1].
+ * 4. Predefined functions implemented in TypeScript:
+ *    - File I/O: read_file, write_file, append_file, read_lines, read_json, write_json, read_csv, write_csv, file_exists, delete_file.
+ *    - Data structures:
+ *      * List/Array: list, len, push, pop, shift, unshift, insert, remove_at, slice, concat, reverse, sort, contains, index_of, join, unique, flatten, first, last, is_empty, sum, avg.
+ *      * Hash/Map: map, keys, values, entries, from_entries, has_key, get, set, delete_key, merge, clone, clear, size.
+ *    - JSON processing: data = json(out), json_parse, json_parse_safe, json_stringify, pluck, filter_by, find_by.
+ *    - System & Process: system() returning SystemResult, prompt_human() for attended terminal pause/handoff.
+ *    - Comprehensive string operations (split, lines, words, join, trim, upper, lower, contains, replace, slice, etc.).
+ * 5. Register new functions: API allowing host TypeScript functions to be registered and checked statically.
+ *
+ * Security & Authority Model:
+ * LMScript executes with full operator authority (no sandbox). File I/O operations (read_file,
+ * write_file, etc.) and shell processes (system()) execute with the local permissions and environment
+ * of the invoking user. Scripts should only be accepted and run from trusted operator sources.
+ */
+export interface SourceLocation {
+    line: number;
+    column: number;
+    file?: string;
+}
+export interface Diagnostic {
+    message: string;
+    line: number;
+    column: number;
+    severity: "error" | "warning";
+    file?: string;
+}
+export declare class LMScriptError extends Error {
+    readonly message: string;
+    readonly line: number;
+    readonly column: number;
+    readonly stage: "LEXER" | "PARSER" | "CHECKER" | "RUNTIME";
+    readonly file?: string;
+    constructor(message: string, line: number, column: number, stage: "LEXER" | "PARSER" | "CHECKER" | "RUNTIME", file?: string);
+}
+export declare class LMScriptExit extends Error {
+    readonly isControlFlow = true;
+    readonly exitCode: number;
+    constructor(exitCode?: number);
+}
+/**
+ * Formats a diagnostic with a visual code snippet and caret pointer.
+ */
+export declare function formatDiagnostic(diag: Diagnostic, source?: string): string;
+/**
+ * Result record returned by `system()`.
+ *
+ * Invariants & Contract Guarantees:
+ * 1. Strict Completion: `system()` is strictly a completion primitive and always awaits
+ *    process exit. It does not return running or detached processes.
+ * 2. Null-No-Overload: `code: null` strictly denotes abnormal termination (killed by signal
+ *    or timed out). `code: null` NEVER means "still running" or "detached".
+ * 3. Future Background Decoupling: Any future non-blocking background handle will be a separate
+ *    discriminated record (`{ kind: 'process', pid, started_at }`) with dedicated wait/poll
+ *    primitives, rather than overloading `SystemResult` with nullable fields. Handles carry
+ *    `started_at` timestamp to protect against PID recycling.
+ */
+export interface SystemResult {
+    stdout: string;
+    stderr: string;
+    code: number | null;
+    signal: string | null;
+    timed_out: boolean;
+    duration_ms: number;
+    pid: number | null;
+}
+export declare function createSystemResult(stdout: string, stderr: string, code: number | null, signal?: string | null, timedOut?: boolean, durationMs?: number, pid?: number | null): SystemResult;
+export declare function shellQuote(value: any): string;
+export declare function systemSync(cmd: string | any[], timeoutMs?: number): SystemResult;
+/**
+ * Safely parses JSON string with preamble and markdown fence recovery.
+ * Returns `fallback` (defaulting to null) on parse failure rather than throwing.
+ */
+export declare function safeParseJson(raw: any, fallback?: any): any;
+/**
+ * Synchronous operator prompt on terminal stdin.
+ * Returns the entered string (with trailing newline stripped), or null if stdin is closed/non-interactive.
+ */
+export declare function promptHumanSync(question?: any): string | null;
+/**
+ * Asynchronous operator prompt on terminal or provided input/output stream.
+ * Returns the entered string, or null if stdin is closed or non-interactive without pending data.
+ */
+export declare function promptHumanAsync(question?: any, inStream?: any, outStream?: any): Promise<string | null>;
+export declare function parseCsv(text: string, hasHeader?: boolean, delimiter?: string): any[];
+export declare function stringifyCsv(data: any[], delimiter?: string): string;
+export type TokenType = "FN" | "LET" | "IF" | "ELSE" | "WHILE" | "FOR" | "RETURN" | "BREAK" | "CONTINUE" | "TRUE" | "FALSE" | "NULL" | "PARALLEL" | "SYNC" | "IMPORT" | "IDENTIFIER" | "NUMBER" | "STRING" | "PLUS" | "MINUS" | "STAR" | "SLASH" | "PERCENT" | "ASSIGN" | "EQUAL" | "NOT_EQUAL" | "LESS" | "LESS_EQUAL" | "GREATER" | "GREATER_EQUAL" | "AND" | "OR" | "NOT" | "DOT" | "COLON" | "LPAREN" | "RPAREN" | "LBRACE" | "RBRACE" | "LBRACKET" | "RBRACKET" | "COMMA" | "SEMICOLON" | "EOF";
+export interface Token {
+    type: TokenType;
+    value: string;
+    literal?: any;
+    line: number;
+    column: number;
+}
+export declare class Lexer {
+    private readonly source;
+    private readonly length;
+    private readonly file?;
+    private pos;
+    private line;
+    private column;
+    constructor(source: string, file?: string);
+    tokenize(): Token[];
+    private peek;
+    private peekNext;
+    private advance;
+    private match;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+    private skipWhitespaceAndComments;
+    private readNumber;
+    private readString;
+    private tryReadHeredoc;
+    private readIdentifier;
+}
+export type BinaryOp = "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "&&" | "||";
+export type UnaryOp = "!" | "-";
+export interface NodeBase {
+    line: number;
+    column: number;
+    file?: string;
+}
+export type Expr = LiteralExpr | IdentifierExpr | AssignExpr | IndexAssignExpr | TupleAssignExpr | UnaryExpr | BinaryExpr | CallExpr | ArrayExpr | IndexExpr | GroupingExpr | TupleExpr | ObjectExpr | ParallelExpr;
+export interface ParallelExpr extends NodeBase {
+    kind: "ParallelExpr";
+    tasks: CallExpr[];
+}
+export interface LiteralExpr extends NodeBase {
+    kind: "LiteralExpr";
+    value: any;
+}
+export interface IdentifierExpr extends NodeBase {
+    kind: "IdentifierExpr";
+    name: string;
+}
+export interface AssignExpr extends NodeBase {
+    kind: "AssignExpr";
+    target: string;
+    value: Expr;
+}
+export interface IndexAssignExpr extends NodeBase {
+    kind: "IndexAssignExpr";
+    target: Expr;
+    index: Expr;
+    value: Expr;
+}
+export interface TupleAssignExpr extends NodeBase {
+    kind: "TupleAssignExpr";
+    targets: string[];
+    value: Expr;
+}
+export interface UnaryExpr extends NodeBase {
+    kind: "UnaryExpr";
+    operator: UnaryOp;
+    operand: Expr;
+}
+export interface BinaryExpr extends NodeBase {
+    kind: "BinaryExpr";
+    operator: BinaryOp;
+    left: Expr;
+    right: Expr;
+}
+export interface CallExpr extends NodeBase {
+    kind: "CallExpr";
+    callee: string;
+    args: Expr[];
+}
+export interface ArrayExpr extends NodeBase {
+    kind: "ArrayExpr";
+    elements: Expr[];
+}
+export interface IndexExpr extends NodeBase {
+    kind: "IndexExpr";
+    target: Expr;
+    index: Expr;
+}
+export interface GroupingExpr extends NodeBase {
+    kind: "GroupingExpr";
+    expression: Expr;
+}
+export interface TupleExpr extends NodeBase {
+    kind: "TupleExpr";
+    elements: Expr[];
+}
+export interface ObjectProperty {
+    key: string;
+    value: Expr;
+}
+export interface ObjectExpr extends NodeBase {
+    kind: "ObjectExpr";
+    properties: ObjectProperty[];
+}
+export type Stmt = ImportStmt | FunctionDeclStmt | VarDeclStmt | TupleVarDeclStmt | IfStmt | WhileStmt | ForStmt | ReturnStmt | BreakStmt | ContinueStmt | SyncAssignStmt | SyncIndexAssignStmt | SyncCallStmt | ExprStmt | BlockStmt;
+export interface ImportStmt extends NodeBase {
+    kind: "ImportStmt";
+    path: string;
+}
+export interface SyncAssignStmt extends NodeBase {
+    kind: "SyncAssignStmt";
+    target: string;
+    value: Expr;
+}
+export interface SyncIndexAssignStmt extends NodeBase {
+    kind: "SyncIndexAssignStmt";
+    target: Expr;
+    index: Expr;
+    value: Expr;
+}
+export interface SyncCallStmt extends NodeBase {
+    kind: "SyncCallStmt";
+    call: CallExpr;
+}
+export interface FunctionDeclStmt extends NodeBase {
+    kind: "FunctionDeclStmt";
+    name: string;
+    params: string[];
+    body: BlockStmt;
+}
+export interface VarDeclStmt extends NodeBase {
+    kind: "VarDeclStmt";
+    name: string;
+    initializer?: Expr;
+}
+export interface TupleVarDeclStmt extends NodeBase {
+    kind: "TupleVarDeclStmt";
+    names: string[];
+    initializer: Expr;
+}
+export interface IfStmt extends NodeBase {
+    kind: "IfStmt";
+    condition: Expr;
+    thenBranch: Stmt;
+    elseBranch?: Stmt;
+}
+export interface WhileStmt extends NodeBase {
+    kind: "WhileStmt";
+    condition: Expr;
+    body: Stmt;
+}
+export interface ForStmt extends NodeBase {
+    kind: "ForStmt";
+    init?: Stmt;
+    condition?: Expr;
+    update?: Expr;
+    body: Stmt;
+}
+export interface ReturnStmt extends NodeBase {
+    kind: "ReturnStmt";
+    value?: Expr;
+}
+export interface BreakStmt extends NodeBase {
+    kind: "BreakStmt";
+}
+export interface ContinueStmt extends NodeBase {
+    kind: "ContinueStmt";
+}
+export interface ExprStmt extends NodeBase {
+    kind: "ExprStmt";
+    expr: Expr;
+}
+export interface BlockStmt extends NodeBase {
+    kind: "BlockStmt";
+    statements: Stmt[];
+}
+export interface Program extends NodeBase {
+    kind: "Program";
+    statements: Stmt[];
+}
+export declare function attachSourceFile(node: any, file: string): void;
+export declare class Parser {
+    private readonly tokens;
+    private current;
+    private readonly file?;
+    constructor(tokens: Token[], file?: string);
+    parse(): Program;
+    private parseDeclaration;
+    private parseImportStmt;
+    private parseFunctionDecl;
+    private parseVarDecl;
+    private parseStatement;
+    private parseSyncStatement;
+    private parseIfStatement;
+    private parseWhileStatement;
+    private parseForStatement;
+    private parseReturnStatement;
+    private parseBreakStatement;
+    private parseContinueStatement;
+    private parseBlockBody;
+    private parseExpressionStatement;
+    parseExpression(): Expr;
+    private parseAssignment;
+    private parseLogicalOr;
+    private parseLogicalAnd;
+    private parseEquality;
+    private parseRelational;
+    private parseAdditive;
+    private parseMultiplicative;
+    private parseUnary;
+    private parseCallAndIndex;
+    private parsePrimary;
+    private match;
+    private check;
+    private advance;
+    private isAtEnd;
+    private peek;
+    private previous;
+    private consume;
+    private consumeOptionalSemicolon;
+}
+export declare const STDLIB_SOURCE = "# LMScript Standard Library (std.lms)\n\n# String Utilities\nfn is_blank(s) {\n  if (s == null) {\n    return true;\n  }\n  return len(trim(s)) == 0;\n}\n\n# Array Utilities\nfn chunk(arr, size) {\n  if (size <= 0) {\n    return [];\n  }\n  res = [];\n  current = [];\n  for (i = 0; i < len(arr); i = i + 1) {\n    push(current, arr[i]);\n    if (len(current) == size) {\n      push(res, current);\n      current = [];\n    }\n  }\n  if (len(current) > 0) {\n    push(res, current);\n  }\n  return res;\n}\n\nfn compact(arr) {\n  res = [];\n  for (i = 0; i < len(arr); i = i + 1) {\n    item = arr[i];\n    if (item != null) {\n      push(res, item);\n    }\n  }\n  return res;\n}\n\nfn zip(arr1, arr2) {\n  res = [];\n  limit = len(arr1);\n  if (len(arr2) < limit) {\n    limit = len(arr2);\n  }\n  for (i = 0; i < limit; i = i + 1) {\n    push(res, [arr1[i], arr2[i]]);\n  }\n  return res;\n}\n\nfn take(arr, n) {\n  res = [];\n  limit = n;\n  if (limit > len(arr)) {\n    limit = len(arr);\n  }\n  for (i = 0; i < limit; i = i + 1) {\n    push(res, arr[i]);\n  }\n  return res;\n}\n\nfn drop(arr, n) {\n  res = [];\n  start = n;\n  if (start < 0) {\n    start = 0;\n  }\n  for (i = start; i < len(arr); i = i + 1) {\n    push(res, arr[i]);\n  }\n  return res;\n}\n\n# Math Utilities\nfn clamp(val, low, high) {\n  if (val < low) {\n    return low;\n  }\n  if (val > high) {\n    return high;\n  }\n  return val;\n}\n";
+export declare function getStdlibProgram(): Program;
+export interface CheckOptions {
+    /** Inspect literal built-in read paths against the current filesystem. No script evaluation. */
+    checkFiles?: boolean;
+    /** Pre-defined global variable names available without declaration (e.g. args, ARGV) */
+    globals?: string[];
+    /** File path of the script being checked/executed */
+    file?: string;
+    /** Base directory for resolving relative imports (defaults to process.cwd() or path.dirname(file)) */
+    baseDir?: string;
+    /** Disable implicit standard library inclusion */
+    noStdlib?: boolean;
+    /** Custom module resolver for virtual files / test isolation */
+    moduleResolver?: (specifier: string, fromFile?: string) => {
+        path: string;
+        source: string;
+    };
+    /** Custom stderr output writer for runtime error logs */
+    stderr?: (text: string) => void;
+}
+export type CompileOptions = CheckOptions;
+export declare function compileProgram(source: string, options?: CompileOptions): {
+    program: Program;
+    loadedFiles: string[];
+};
+export interface FunctionSignature {
+    name: string;
+    paramCount: number;
+    params: string[];
+    isHost: boolean;
+    isStdlib?: boolean;
+    file?: string;
+    line: number;
+    column: number;
+}
+export type HostFunctionArity = number | {
+    min: number;
+    max?: number;
+};
+type CheckableHostFunction = {
+    arity?: HostFunctionArity;
+    readsFile?: boolean;
+    isContainerMutation?: boolean;
+};
+export declare class StaticChecker {
+    private diagnostics;
+    private readonly hostFunctions;
+    private readonly options;
+    private readonly functions;
+    private currentScope;
+    private loopDepth;
+    private inFunction;
+    hasConcurrency: boolean;
+    constructor(hostFunctions: Map<string, CheckableHostFunction>, options?: CheckOptions);
+    check(program: Program): Diagnostic[];
+    private addError;
+    private collectFunction;
+    private checkStmt;
+    private checkReadPath;
+    private checkExpr;
+}
+export declare class ReturnSignal {
+    readonly value: any;
+    constructor(value: any);
+}
+export declare class BreakSignal {
+}
+export declare class ContinueSignal {
+}
+export declare class Environment {
+    private static nextId;
+    readonly id: number;
+    private readonly values;
+    readonly parent?: Environment;
+    constructor(parent?: Environment);
+    resolveBinding(name: string): {
+        env: Environment;
+        name: string;
+    } | undefined;
+    define(name: string, value: any): void;
+    get(name: string): any;
+    has(name: string): boolean;
+    set(name: string, value: any): void;
+}
+export declare class AsyncLock {
+    private holderTaskId?;
+    private depth;
+    private readonly waiters;
+    acquire(taskId?: number, timeoutMs?: number): Promise<void>;
+    release(): void;
+    withLock<T>(action: () => Promise<T>, taskId?: number, timeoutMs?: number): Promise<T>;
+}
+export declare class AsyncLockManager {
+    private readonly bindingLocks;
+    private readonly objectLocks;
+    getBindingLock(bindingKey: string): AsyncLock;
+    getObjectLock(target: object): AsyncLock;
+}
+export type HostFunction = (...args: any[]) => any;
+export interface FunctionDoc {
+    name: string;
+    category: string;
+    module?: string;
+    signature: string;
+    description: string;
+    parameters?: Array<{
+        name: string;
+        type: string;
+        description: string;
+    }>;
+    returns?: {
+        type: string;
+        description: string;
+    };
+    example?: string;
+}
+export interface ScriptModule {
+    name: string;
+    description?: string;
+    docs?: FunctionDoc[];
+    register?: (engine: LMScript, context?: any) => void;
+}
+export interface HostFunctionMeta {
+    fn: HostFunction;
+    arity?: HostFunctionArity;
+    description?: string;
+    readsFile?: boolean;
+    isDefault?: boolean;
+    isContainerMutation?: boolean;
+    doc?: FunctionDoc;
+}
+export declare class Interpreter {
+    private globalEnv;
+    private readonly userFunctions;
+    private readonly hostFunctions;
+    private readonly stdout;
+    private readonly stderr?;
+    private readonly lockManager;
+    private readonly isAsync;
+    private nextTaskId;
+    private readonly initialGlobals?;
+    private callDepth;
+    private readonly asyncCallDepth;
+    private readonly recordedErrors;
+    constructor(hostFunctions: Map<string, HostFunctionMeta>, stdout?: (text: string) => void, isAsync?: boolean, initialGlobals?: Map<string, any>, stderr?: (text: string) => void);
+    evaluateProgram(program: Program): any;
+    private execStmt;
+    private evalExpr;
+    private isTruthy;
+    evaluateProgramAsync(program: Program): Promise<any>;
+    private execStmtAsync;
+    private evalExprAsync;
+    private invokeCallAsync;
+    getRecordedErrors(): string[];
+}
+export interface ExecutionResult {
+    success: boolean;
+    value?: any;
+    exitCode?: number;
+    diagnostics: Diagnostic[];
+    output: string[];
+    errors?: string[];
+}
+export declare const LANGUAGE_DOCS: FunctionDoc[];
+export declare const BUILTIN_FUNCTION_DOCS: FunctionDoc[];
+export declare const STDLIB_FUNCTION_DOCS: FunctionDoc[];
+export declare class LMScript {
+    private readonly hostFunctions;
+    private readonly functionDocs;
+    private readonly registeredModules;
+    private readonly functionOriginModule;
+    private currentRegisteringModule;
+    private outputLogs;
+    isAsyncMode: boolean;
+    constructor();
+    private registerDefaultDocs;
+    registerFunctionDoc(doc: FunctionDoc): this;
+    registerModule(module: ScriptModule, context?: any): this;
+    getModules(): ScriptModule[];
+    getModule(name: string): ScriptModule | undefined;
+    getFunctionsByModule(moduleName: string): FunctionDoc[];
+    getFunctionDocs(): FunctionDoc[];
+    getFunctionDoc(name: string): FunctionDoc | undefined;
+    getFunctionCategories(): string[];
+    getFunctionsByCategory(category: string): FunctionDoc[];
+    /**
+     * Requirement 4: Predefined functions implemented in TypeScript.
+     * Includes File I/O, Lists/Arrays, Hashes/Maps, JSON, Shell, and Strings.
+     */
+    private registerPredefinedFunctions;
+    /**
+     * Requirement 5: Register new TypeScript functions into the runtime.
+     */
+    registerFunction(name: string, fn: HostFunction, arity?: HostFunctionArity, descriptionOrOptions?: string | {
+        description?: string;
+        isDefault?: boolean;
+        isContainerMutation?: boolean;
+        doc?: FunctionDoc;
+        allowOverwrite?: boolean;
+        module?: string;
+    }, isDefault?: boolean, isContainerMutation?: boolean): this;
+    getFunctionOriginModule(name: string): string | undefined;
+    private readonly initialGlobals;
+    setGlobal(name: string, value: any): this;
+    getGlobal(name: string): any;
+    /**
+     * Requirement 2: Scan all and check before execution without generating intermediate files.
+     */
+    scanAndCheck(source: string, options?: CompileOptions): {
+        ast: Program | null;
+        diagnostics: Diagnostic[];
+        hasConcurrency: boolean;
+    };
+    /**
+     * Complete execution pipeline:
+     * 1. Scans and parses source.
+     * 2. Runs static checker upfront.
+     * 3. If any static errors are found, aborts immediately WITHOUT executing.
+     * 4. If checks pass, executes AST in-memory.
+     */
+    run(source: string, options?: CompileOptions): ExecutionResult;
+    /**
+     * Asynchronous execution pipeline supporting parallel tasks and sync statements.
+     */
+    runAsync(source: string, options?: CompileOptions): Promise<ExecutionResult>;
+    private lastRecordedErrors;
+    getRecordedErrors(): string[];
+    hasFunction(name: string): boolean;
+    getRegisteredFunctions(): string[];
+}
+export declare function runDemoSuite(): Promise<boolean>;
+export {};

package/dist/shared/policy.d.ts

@@ -0,0 +1,74 @@
+export type SubscriptionTier = "free" | "premium" | "admin";
+export interface LocalwebPolicy {
+    schema: "localweb.policy.v1";
+    policyId: string;
+    tier: SubscriptionTier;
+    version: number;
+    leases: {
+        mailboxUrlTtlMs: number;
+        refreshBeforeExpiryMs: number;
+    };
+    polling: {
+        notLoggedInMs: number;
+        idleForegroundMs: number;
+        idleBackgroundMs: number;
+        busyMs: number;
+        jitterRatio: number;
+    };
+    heartbeats: {
+        browserMs: number;
+        appMs: number;
+        ttlMs: number;
+    };
+    limits: {
+        enforced: boolean;
+        appsPerUser: number;
+        activeMinutesPerDay: number;
+        activityBucketMs: number;
+        maxMailboxGetsPerDay: number;
+        maxMailboxPutsPerDay: number;
+        maxControlRequestsPerDay: number;
+        maxMessagesPerMailbox: number;
+        maxMailboxBytes: number;
+        maxMessageBytes: number;
+        maxProgressPutMs: number;
+    };
+    overLimit: {
+        mode: "slowdown" | "deny_url_refresh" | "deny_requests";
+        pollMs: number;
+        denyUrlRefresh: boolean;
+    };
+}
+export interface UsageCounters {
+    active: boolean;
+    mailboxGets: number;
+    mailboxPuts: number;
+    controlRequests: number;
+    busyMs: number;
+    bytesIn: number;
+    bytesOut: number;
+}
+export interface UsageSummary {
+    date: string;
+    activeMinutesToday: number;
+    mailboxGetsToday: number;
+    mailboxPutsToday: number;
+    controlRequestsToday: number;
+    busyMsToday: number;
+    bytesInToday: number;
+    bytesOutToday: number;
+    activeMinutesLimit: number;
+    mailboxGetsLimit: number;
+    mailboxPutsLimit: number;
+    controlRequestsLimit: number;
+    overLimit: boolean;
+    overLimitReasons: string[];
+}
+export interface EffectivePolicy {
+    policy: LocalwebPolicy;
+    usage: UsageSummary;
+}
+export declare const DEFAULT_USAGE_COUNTERS: UsageCounters;
+export declare function emptyUsageSummary(date: string, policy: LocalwebPolicy): UsageSummary;
+export declare function evaluateUsageLimits(summary: UsageSummary, policy: LocalwebPolicy): UsageSummary;
+export declare function effectiveRetryAfterMs(effective: EffectivePolicy, fallbackMs: number): number;

package/dist/shared-lib/db.d.ts

@@ -0,0 +1,25 @@
+import { createDal, Dal } from '../db/index.js';
+export { createDal, Dal, };
+export type { AgentInflightAcquireOptions, AgentInflightAcquireResult, AgentInflightInput, AgentInflightObservedHolder, AgentInflightRow, TerminalLockRecord, TrackedInvocationFinishPatch, TrackedInvocationInput, TrackedInvocationKind, TrackedInvocationListFilter, TrackedInvocationOrigin, TrackedInvocationRow, TrackedInvocationStatus, TrackedInvocationTerminalClaimFilter, WorkflowRow, WorkflowVersionRow, TriggerInstanceRow, TeamRow, TeamMemberRow, ProjectRow, JobRow, RunRow, StepRow, AttentionRow, } from '../db/index.js';
+export interface OpenLmctlStateDbOptions {
+    /**
+     * Explicit state.db path. When omitted, uses the same resolver as the CLI:
+     * db flag equivalent -> LMCTL_DB -> active workspace -> legacy/default db.
+     */
+    path?: string;
+    /**
+     * Open the existing DB read-only and set PRAGMA query_only=ON.
+     * Write mode uses the normal migration-backed createDal path.
+     */
+    readonly?: boolean;
+}
+export interface LmctlStateDbHandle {
+    path: string;
+    readonly: boolean;
+    dal: Dal;
+    close(): void;
+}
+export declare function resolveLmctlStateDbPath(path?: string): string;
+export declare function openLmctlStateDb(options?: OpenLmctlStateDbOptions): LmctlStateDbHandle;
+export declare function openReadonlyLmctlStateDb(path?: string): LmctlStateDbHandle;
+export declare function createReadonlyDal(path: string): Dal;

package/dist/shared-lib/passive-session-reader.d.ts

@@ -0,0 +1,2 @@
+export { NativePassiveSessionReader, createPassiveSessionReader, } from '../providers/passive-session-reader.js';
+export type { Source, ReadLimits, SourceState, NativeResponseMetadata, Discovery, Snapshot, PassiveSessionReader, PassiveSessionReaderOptions, } from '../providers/passive-session-reader.js';

package/dist/shared-lib/provider-parse.d.ts

@@ -0,0 +1,6 @@
+export { aggregateResultEvents, createStreamJsonProcessor, joinResultTurns, supportsStreamJson, } from '../providers/parsers/stream-json.js';
+export type { AggregatedResultEvents, StreamJsonProcessor, StreamJsonResult, } from '../providers/parsers/stream-json.js';
+export { acpSessionIdFromResponse, acpStopReasonFromResponse, createAcpOutputProcessor, isolateGeminiLatestAgentMessage, supportsAcp, } from '../providers/parsers/acp.js';
+export type { AcpOutputProcessor, AcpOutputProcessorResult, AcpResult, } from '../providers/parsers/acp.js';
+export { buildCodexThreadResumeParams, buildCodexThreadStartParams, buildInitializePayload, classifyCodexErrorDisposition, createCodexAgentAccumulator, createCodexTurnState, flushCodexAgentAccumulator, processCodexAgentNotification, recordCodexErrorNotification, resolveCodexTurnCompletion, } from '../providers/parsers/codex-app-server.js';
+export type { AgentMessageItemState, AgentMessagePhase, CodexAgentAccumulatorState, CodexInitializePayload, CodexItemMismatchInfo, CodexTurnState, } from '../providers/parsers/codex-app-server.js';