@eyeauras/insight-cli 0.0.0-stage → 0.2.0

package/dist/src/research.d.ts

@@ -0,0 +1,184 @@
+import type { Artifact } from './artifacts.js';
+import type { GhidraContext, Scope, ScalarChange, Publication, DebuggerState, GhidraLoadSettings } from './workspace.js';
+import { Workspace } from './workspace.js';
+import type { ToolMode } from './contexts.js';
+import type { ScriptPage } from './scripts.js';
+export interface ResearchBackend {
+    sdkFile?(operation: string, p: Record<string, unknown>): Promise<Record<string, unknown>>;
+    archivePayloads?(scope: Scope, p: Record<string, unknown>): Promise<unknown>;
+    debuggerStart?(scope: Scope): Promise<void>;
+    debuggerCall?(scope: Scope, operation: string, p?: Record<string, unknown>): Promise<unknown>;
+    debuggerSaved?(scope: Scope): Promise<DebuggerState>;
+    debuggerSelect?(scope: Scope, trace: string): Promise<void>;
+    debuggerStop?(scope: Scope): Promise<void>;
+    debuggerLaunch?(scope: Scope, p: Record<string, unknown>, request: string): Promise<unknown>;
+    ui?(scope: Scope, operation: string, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    project?(operation: string, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    projectOutcome?(requestId: string, expected: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+    administration?(operation: string, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    open(scope: Scope, request?: string): Promise<GhidraContext>;
+    call(scope: Scope, operation: string, parameters?: Record<string, unknown>): Promise<unknown>;
+    saved(scope: Scope): Promise<Artifact>;
+    mode(scope: Scope, mode: ToolMode): Promise<void>;
+    close(scope: Scope): Promise<void>;
+    closed?(scope: Scope): Promise<boolean>;
+    dispose(): Promise<void>;
+    latest?(target: string): Promise<{
+        revision: number;
+        snapshot: Artifact;
+    }>;
+    fields?(snapshot: Artifact, changes: Pick<ScalarChange, 'address' | 'field'>[]): Promise<Record<string, {
+        value: string | null;
+        dependency: string;
+        exists: boolean;
+    }>>;
+    candidate?(target: string, snapshot: Artifact, changes: ScalarChange[]): Promise<Artifact>;
+    publish?(publication: Publication): Promise<{
+        state: 'published';
+        revision: number;
+    } | {
+        state: 'conflict';
+        applied: 0;
+    }>;
+    recover?(publication: Publication): Promise<{
+        state: 'verified';
+        revision: number;
+    } | {
+        state: 'unknown';
+    }>;
+    recoverModel?(target: string): Promise<boolean>;
+    scripts?(scope: Scope, filter: string, limit: number, offset: number): Promise<ScriptPage>;
+    inspect?(snapshot: Artifact, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    pair?(selected: Scope, other: Scope, snapshot: Artifact, operation: string, parameters: Record<string, unknown>): Promise<unknown>;
+    transfer?(selected: Scope, source: Artifact, dryRun: boolean): Promise<unknown>;
+    transferCheck?(selected: Scope, source: Artifact, candidate: Artifact): Promise<unknown>;
+}
+export declare function address(value: unknown): string;
+export declare const publicAddress: (value: unknown) => string;
+export declare function scalarText(value: unknown): string | null;
+export declare function commentKind(value: unknown): "eol" | "pre" | "post" | "plate" | "repeatable";
+export declare function number(value: unknown, maximum: number, minimum?: number): number;
+export declare function scope(options: Record<string, unknown>): Scope;
+/** One ordered working context per tuple, shared by every transport through the Factory owner. */
+export declare class Research {
+    readonly workspace: Workspace;
+    private readonly backend;
+    private readonly tasks;
+    constructor(workspace: Workspace, backend: () => Promise<ResearchBackend>, tasks?: Map<string, Promise<unknown>>);
+    ordered<T>(selected: Scope, action: () => Promise<T>): Promise<T>;
+    boundary<T>(selected: Scope, action: () => Promise<T>): Promise<T>;
+    status(selected: Scope): {
+        externalRequests: {
+            operation: string;
+            state: import("./workspace.js").RequestState;
+            requestId?: string | undefined;
+        }[];
+        externalRequestsTruncated: boolean;
+        ghidra: {
+            syncPolicy: import("./workspace.js").SyncPolicy;
+            state: "opening" | "ready" | "stopped" | "needs_recovery";
+            baseRevision: string | undefined;
+            sharedRevision: string | undefined;
+            pendingChanges: number;
+            mergeState: string;
+            conflicts: {
+                address: string;
+                field: "function.name" | "comment.eol" | "comment.pre" | "comment.post" | "comment.plate" | "comment.repeatable";
+                original: string | null;
+                local: string | null;
+                shared: string | null;
+            }[];
+            unresolvedRequests: {
+                operation: string;
+                state: import("./workspace.js").RequestState;
+                requestId?: string | undefined;
+            }[];
+        };
+        session: string;
+        target: string;
+    };
+    open(target: string, session: string | 'new', settings: GhidraLoadSettings, callerId?: string, mode?: ToolMode): Promise<{
+        [k: string]: unknown;
+    } | {
+        session: string;
+        target: string;
+        state: string;
+        baseRevision: string | undefined;
+        sharedRevision: string | undefined;
+        pendingChanges: number;
+    }>;
+    read(selected: Scope, operation: string, parameters: Record<string, unknown>): Promise<unknown>;
+    scripts(selected: Scope, filter: string, limit: number, offset: number): Promise<ScriptPage>;
+    paired<T>(selected: Scope, other: Scope, action: () => Promise<T>): Promise<T>;
+    crossRead(selected: Scope, other: Scope, operation: string, parameters: Record<string, unknown>): Promise<unknown>;
+    private savedScalars;
+    transfer(selected: Scope, source: Scope, dryRun: boolean, callerId?: string): Promise<unknown>;
+    strings(selected: Scope, contains: string, limit: number, offset: number): Promise<{
+        scan?: unknown;
+        totalKnown?: boolean | undefined;
+        items: {
+            address: string;
+            text: string;
+        }[];
+        offset: number;
+        limit: number;
+        total: number;
+        truncated: boolean;
+        session: string;
+        target: string;
+    }>;
+    function(selected: Scope, at: string, decompile?: boolean): Promise<{
+        code?: unknown;
+        truncated?: boolean | undefined;
+        address: string;
+        name: unknown;
+        signature: string;
+        comments: Record<string, string | null>;
+        session: string;
+        target: string;
+    }>;
+    xrefs(selected: Scope, at: string, limit: number, offset: number): Promise<{
+        items: ({
+            from: null;
+            to: string;
+            kind: string;
+            source: string;
+        } | {
+            function?: {
+                address: string;
+                name: unknown;
+            } | undefined;
+            from: string;
+            to: string;
+            kind: string;
+            source?: undefined;
+        })[];
+        offset: number;
+        limit: number;
+        total: number;
+        truncated: boolean;
+        session: string;
+        target: string;
+    }>;
+    comment(selected: Scope, at: string, kind?: ReturnType<typeof commentKind>): Promise<{
+        kind: "eol" | "pre" | "post" | "plate" | "repeatable";
+        text: string | null | undefined;
+        sharedState: string;
+        address: string;
+        session: string;
+        target: string;
+    } | {
+        comments: Record<string, string | null>;
+        address: string;
+        session: string;
+        target: string;
+    }>;
+    edit(selected: Scope, at: string, field: ScalarChange['field'], value: string | null, callerId?: string, resolution?: {
+        expectedShared: string | null;
+    }): Promise<unknown>;
+    private sharedOrder;
+    private reconcile;
+    merge(selected: Scope, callerId?: string): Promise<unknown>;
+    refresh(selected: Scope, callerId?: string): Promise<unknown>;
+    mutate(selected: Scope, operation: string, parameters: Record<string, unknown>, verify: (backend: ResearchBackend, result: Record<string, unknown>) => Promise<unknown>, callerId?: string, verifySaved?: (backend: ResearchBackend, snapshot: Artifact, result: Record<string, unknown>) => Promise<unknown>): Promise<unknown>;
+}