@eyeauras/insight-cli 0.0.0-stage → 0.1.0

package/dist/src/comment-effects.js

@@ -0,0 +1,55 @@
+import { address } from './research.js';
+import { object, fail } from './model.js';
+const normalize = (value) => value === '' ? null : value;
+export async function verifyComments(backend, snapshot, path, p) {
+    if (!backend.inspect)
+        fail('configuration', 'Batch comments require saved-state inspection.');
+    const inspect = (kind, parameters) => backend.inspect(snapshot, { kind, ...parameters });
+    if (path === '/clear_function_comments') {
+        const ref = String(p.function);
+        let selector;
+        try {
+            selector = { address: address(ref) };
+        }
+        catch {
+            selector = { name: ref };
+        }
+        const value = await inspect('function_comments', selector);
+        if (p.clear_plate !== false && value.plate !== null)
+            fail('partial', 'Saved function plate comment was not cleared.');
+        if (!Array.isArray(value.comments))
+            fail('partial', 'Saved function comment inventory is absent.');
+        for (const item of value.comments) {
+            const comment = object(item);
+            if (comment.kind === 'eol' && p.clear_eol !== false || comment.kind === 'pre' && p.clear_pre !== false)
+                fail('partial', 'Requested function comments remain in saved state.');
+        }
+        return value;
+    }
+    const verified = [];
+    for (const [parameter, kind] of [['decompiler_comments', 'pre'], ['disassembly_comments', 'eol']]) {
+        const requested = p[parameter] ?? [];
+        if (!Array.isArray(requested))
+            fail('invalid', 'Batch comments require arrays of {address,comment}.');
+        const expected = new Map();
+        for (const raw of requested) {
+            const item = object(raw);
+            if (typeof item.comment !== 'string')
+                fail('invalid', 'Each batch comment requires text or empty text to clear.');
+            expected.set(address(item.address), normalize(item.comment));
+        }
+        for (const [at, text] of expected) {
+            const value = await inspect('comments', { address: at });
+            if (value[kind] !== text)
+                fail('partial', 'Saved batch comment differs from the requested text.');
+            verified.push({ address: at, kind, text });
+        }
+    }
+    if (p.plate_comment !== undefined && p.plate_comment !== null && !(path === '/batch_apply_documentation' && p.plate_comment === '')) {
+        const value = await inspect('comments', { address: p.address });
+        if (value.plate !== normalize(p.plate_comment))
+            fail('partial', 'Saved batch plate comment differs from the requested text.');
+        verified.push({ address: p.address, kind: 'plate', text: value.plate });
+    }
+    return { comments: verified };
+}

package/dist/src/contexts.d.ts

@@ -0,0 +1,115 @@
+import type { CommandContext } from '@eyeauras/cli-factory';
+import { type ChildProcess } from 'node:child_process';
+import { type NativeInputs } from './native-inputs.js';
+import { GhidraServer } from './server.js';
+import { Workspace, type Scope, type GhidraContext, type ScalarChange, type Publication, type DebuggerState } from './workspace.js';
+import { type Artifact } from './artifacts.js';
+import { HttpBridge } from './transport.js';
+export type ToolMode = 'headless' | 'gui';
+interface ProcessBinding {
+    pid: number;
+    endpoint: string;
+    root: string;
+    target: string;
+    context?: string;
+    mode: ToolMode;
+    program: string;
+    tokenSecret: string;
+    runtimeFingerprint: string;
+    kind: 'context' | 'shared' | 'bootstrap' | 'candidate';
+    baseRevision?: number;
+    viewEpoch?: number;
+}
+interface Running {
+    binding: ProcessBinding;
+    http: HttpBridge;
+    child?: ChildProcess;
+}
+/** Isolated native contexts. This layer has no agent-facing instance/worker selector. */
+export declare class GhidraContexts {
+    private readonly workspace;
+    private readonly inputs;
+    private readonly c;
+    private readonly running;
+    private readonly modelTasks;
+    private readonly ownedServer;
+    private readonly capacity;
+    constructor(workspace: Workspace, inputs: NativeInputs, c: CommandContext, running?: Map<string, Running>, modelTasks?: Map<string, Promise<void>>, ownedServer?: GhidraServer, capacity?: {
+        slots: Set<string>;
+        inventory?: Promise<void>;
+    });
+    fork(c: CommandContext): GhidraContexts;
+    private directory;
+    private server;
+    administration(operation: string, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    sdkFile(operation: string, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    private prepareRoot;
+    private launch;
+    private verified;
+    private source;
+    private stopRecord;
+    private debuggerReleased;
+    private capture;
+    private shared;
+    private retireLegacyBootstrap;
+    private initialModel;
+    private model;
+    private privateCopy;
+    open(scope: Scope, request?: string): Promise<GhidraContext>;
+    private selected;
+    call(scope: Scope, operation: string, parameters?: Record<string, unknown>): Promise<unknown>;
+    saved(scope: Scope): Promise<Artifact>;
+    scripts(scope: Scope, filter: string, limit: number, offset: number): Promise<import("./scripts.js").ScriptPage>;
+    inspect(snapshot: Artifact, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    private removePeer;
+    private reconcilePeers;
+    private withPeer;
+    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>;
+    mode(scope: Scope, mode: ToolMode): Promise<void>;
+    project(operation: string, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    ui(scope: Scope, operation: string, p: Record<string, unknown>): Promise<Record<string, unknown>>;
+    archivePayloads(scope: Scope, p: Record<string, unknown>): Promise<Record<string, unknown>>;
+    debuggerStart(scope: Scope): Promise<void>;
+    debuggerStop(scope: Scope): Promise<void>;
+    private debuggerHelper;
+    private debuggerHelperRecord;
+    debuggerCall(scope: Scope, operation: string, p?: Record<string, unknown>): Promise<unknown>;
+    private traceHelper;
+    debuggerSaved(scope: Scope): Promise<DebuggerState>;
+    debuggerSelect(scope: Scope, trace: string): Promise<void>;
+    debuggerLaunch(scope: Scope, p: Record<string, unknown>, request: string): Promise<unknown>;
+    projectOutcome(requestId: string, expected: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+    private debuggerMetadataChanges;
+    close(scope: Scope): Promise<void>;
+    closed(scope: Scope): Promise<boolean>;
+    latest(targetId: string): Promise<{
+        revision: number;
+        snapshot: Artifact;
+    }>;
+    fields(snapshot: Artifact, changes: Pick<ScalarChange, 'address' | 'field'>[]): Promise<Record<string, {
+        value: string | null;
+        dependency: string;
+        exists: boolean;
+    }>>;
+    private applyField;
+    candidate(targetId: 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(targetId: string): Promise<boolean>;
+    dispose(): Promise<void>;
+    private inventory;
+}
+export {};