@maximtop/opencode-debug-mode 0.1.0

package/dist/investigation/schema.d.ts

@@ -0,0 +1,184 @@
+import { z } from "zod";
+export declare const HypothesisSchema: z.ZodObject<{
+    id: z.ZodString;
+    rank: z.ZodNumber;
+    statement: z.ZodString;
+    confirmationSignals: z.ZodArray<z.ZodString>;
+    eliminationSignals: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        confirmed: "confirmed";
+        eliminated: "eliminated";
+        open: "open";
+    }>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    invalidatedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const CompletedCheckSchema: z.ZodObject<{
+    id: z.ZodString;
+    summary: z.ZodString;
+    interpretation: z.ZodString;
+    conclusive: z.ZodBoolean;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    completedAt: z.ZodString;
+    invalidatedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const RunReferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodEnum<{
+        "post-fix": "post-fix";
+        "pre-fix": "pre-fix";
+    }>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        planned: "planned";
+        running: "running";
+        timed_out: "timed_out";
+        waiting: "waiting";
+    }>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const ProbeReferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    runId: z.ZodString;
+    hypothesisId: z.ZodString;
+    sourceFile: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        ambiguous: "ambiguous";
+        planned: "planned";
+        registered: "registered";
+        removed: "removed";
+        validated: "validated";
+    }>;
+}, z.core.$strict>;
+export declare const DeveloperConfirmationSchema: z.ZodObject<{
+    id: z.ZodString;
+    statement: z.ZodString;
+    confirmedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const DecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    summary: z.ZodString;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    decidedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const InvestigationStateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodString;
+    problemSummary: z.ZodString;
+    expectedBehavior: z.ZodString;
+    actualBehavior: z.ZodString;
+    runtimeContext: z.ZodObject<{
+        kind: z.ZodEnum<{
+            cli: "cli";
+            extension: "extension";
+            other: "other";
+            web: "web";
+        }>;
+        target: z.ZodString;
+    }, z.core.$strict>;
+    reproduction: z.ZodObject<{
+        method: z.ZodString;
+        requiresUser: z.ZodBoolean;
+        confirmed: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>;
+    successCriteria: z.ZodArray<z.ZodString>;
+    phase: z.ZodEnum<{
+        abandoned: "abandoned";
+        analyzing: "analyzing";
+        baseline: "baseline";
+        cleaning: "cleaning";
+        completed: "completed";
+        escalated: "escalated";
+        fixing: "fixing";
+        hypotheses: "hypotheses";
+        instrumenting: "instrumenting";
+        intake: "intake";
+        verifying: "verifying";
+        waiting_for_reproduction: "waiting_for_reproduction";
+    }>;
+    loopIteration: z.ZodNumber;
+    singleCauseEvidenceRef: z.ZodNullable<z.ZodString>;
+    hypotheses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        rank: z.ZodNumber;
+        statement: z.ZodString;
+        confirmationSignals: z.ZodArray<z.ZodString>;
+        eliminationSignals: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            confirmed: "confirmed";
+            eliminated: "eliminated";
+            open: "open";
+        }>;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        invalidatedBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    completedChecks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        summary: z.ZodString;
+        interpretation: z.ZodString;
+        conclusive: z.ZodBoolean;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        completedAt: z.ZodString;
+        invalidatedBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    runs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodEnum<{
+            "post-fix": "post-fix";
+            "pre-fix": "pre-fix";
+        }>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+            planned: "planned";
+            running: "running";
+            timed_out: "timed_out";
+            waiting: "waiting";
+        }>;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    probeRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        runId: z.ZodString;
+        hypothesisId: z.ZodString;
+        sourceFile: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            ambiguous: "ambiguous";
+            planned: "planned";
+            registered: "registered";
+            removed: "removed";
+            validated: "validated";
+        }>;
+    }, z.core.$strict>>;
+    decidingEvidenceIds: z.ZodArray<z.ZodString>;
+    developerConfirmations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        confirmedAt: z.ZodString;
+    }, z.core.$strict>>;
+    decisions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        summary: z.ZodString;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        decidedAt: z.ZodString;
+    }, z.core.$strict>>;
+    nextAction: z.ZodString;
+    instrumentedFiles: z.ZodArray<z.ZodString>;
+    fixedFiles: z.ZodArray<z.ZodString>;
+    cleanup: z.ZodObject<{
+        status: z.ZodEnum<{
+            complete: "complete";
+            not_started: "not_started";
+            partial: "partial";
+            running: "running";
+        }>;
+        completedResources: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type InvestigationState = z.infer<typeof InvestigationStateSchema>;

package/dist/investigation/store.d.ts

@@ -0,0 +1,30 @@
+import type { Clock } from "../core/clock.js";
+import { type InvestigationState } from "./schema.js";
+export type StateRecoveryResult = {
+    ok: true;
+    state: InvestigationState;
+    warnings: string[];
+} | {
+    ok: false;
+    error: {
+        code: "STATE_MISSING" | "STATE_INVALID" | "STATE_VERSION_UNSUPPORTED";
+        message: string;
+    };
+};
+export declare function initialInvestigationState(now: string): InvestigationState;
+export declare class InvestigationStore {
+    private readonly filename;
+    private readonly clock;
+    private tail;
+    constructor(filename: string, clock?: Clock);
+    create(state: InvestigationState): Promise<number>;
+    read(): Promise<InvestigationState>;
+    readRecovery(): Promise<StateRecoveryResult>;
+    checkpoint(expectedRevision: number, state: InvestigationState): Promise<{
+        state: InvestigationState;
+        bytes: number;
+    }>;
+    private validate;
+    private write;
+    private exclusive;
+}

package/dist/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import type { Clock } from "./core/clock.js";
+export type DebugModePluginOptions = Readonly<{
+    clock?: Clock;
+    tempBase?: string;
+}>;
+export declare function createDebugModePlugin(options?: DebugModePluginOptions): Plugin;
+export declare const DebugModePlugin: Plugin;

package/dist/probes/extension-permissions.d.ts

@@ -0,0 +1,8 @@
+import type { z } from "zod";
+import type { PermissionChangeSchema } from "../session/types.js";
+export type PermissionChange = z.infer<typeof PermissionChangeSchema>;
+export declare function addLoopbackPermission(manifestPath: string, matchPattern: string): Promise<PermissionChange>;
+export declare function removeLoopbackPermission(manifestPath: string, change: PermissionChange): Promise<{
+    status: "success" | "already-clean" | "failed";
+    reason?: string;
+}>;

package/dist/probes/helper.d.ts

@@ -0,0 +1,22 @@
+export type TransportHelperResult = Readonly<{
+    relativePath: string;
+    requiredImport: string;
+    sha256: string;
+    bytes: number;
+}>;
+export declare class TransportHelper {
+    private readonly projectRoot;
+    private readonly recordOwnedFile?;
+    constructor(projectRoot: string, recordOwnedFile?: ((value: {
+        path: string;
+        sha256: string;
+        bytes: number;
+    }) => void | Promise<void>) | undefined);
+    create(options: {
+        targetPath: string;
+        host: "127.0.0.1" | "::1";
+        port: number;
+        token: string;
+        runtime: "web" | "extension-background";
+    }): Promise<TransportHelperResult>;
+}

package/dist/probes/registry.d.ts

@@ -0,0 +1,18 @@
+import type { EventInput } from "../evidence/types.js";
+import type { ManifestStore } from "../session/manifest-store.js";
+import type { ManifestProbe } from "../session/types.js";
+import { type ProbePlanInput } from "./types.js";
+export declare class ProbeRegistry {
+    private readonly store;
+    private readonly projectRoot;
+    private readonly hasHypothesis;
+    constructor(store: ManifestStore, projectRoot: string, hasHypothesis: (id: string) => Promise<boolean>);
+    plan(input: ProbePlanInput): Promise<ManifestProbe & {
+        markerBlock: string;
+    }>;
+    register(id: string): Promise<ManifestProbe>;
+    validate(probeIds: string[]): Promise<void>;
+    requireValidatedForRun(runId: string): Promise<void>;
+    validateEvent(input: EventInput): Promise<EventInput>;
+    private update;
+}

package/dist/probes/remove.d.ts

@@ -0,0 +1,16 @@
+import type { ManifestProbe } from "../session/types.js";
+export type ProbeRemovalResult = {
+    status: "success";
+    file: string;
+    reason?: never;
+} | {
+    status: "already-clean";
+    file: string;
+    reason?: never;
+} | {
+    status: "failed";
+    file: string;
+    reason: string;
+    line?: number;
+};
+export declare function removeOwnedProbe(probe: ManifestProbe): Promise<ProbeRemovalResult>;

package/dist/probes/template.d.ts

@@ -0,0 +1,21 @@
+import { type ProbeSampling, type ProbeTransport } from "./types.js";
+export type ProbeTemplateInput = Readonly<{
+    sessionId: string;
+    runId: string;
+    runLabel: "pre-fix" | "post-fix";
+    hypothesisId: string;
+    probeId: string;
+    sourceFile: string;
+    sourceLine: number;
+    message: string;
+    captures: Array<{
+        label: string;
+        path: string;
+    }>;
+    transport: ProbeTransport;
+    sampling: ProbeSampling;
+    contentAdapter?: "chrome.runtime.sendMessage" | "browser.runtime.sendMessage" | "wrapper.sendMessage";
+}>;
+export declare function createProbeTemplate(input: ProbeTemplateInput): {
+    markerBlock: string;
+};

package/dist/probes/types.d.ts

@@ -0,0 +1,24 @@
+export declare const SAFE_CAPTURE: RegExp;
+export type ProbeTransport = "process" | "http-web" | "extension-background" | "extension-content";
+export type ProbeSampling = {
+    mode: "every";
+    n: number;
+} | {
+    mode: "aggregate";
+    windowMs: number;
+};
+export type ProbePlanInput = Readonly<{
+    runId: string;
+    hypothesisId: string;
+    sourceFile: string;
+    sourceLine: number;
+    sourceColumn?: number;
+    message: string;
+    captures: Array<{
+        label: string;
+        path: string;
+    }>;
+    transport: ProbeTransport;
+    sampling: ProbeSampling;
+    markerBlock?: string;
+}>;

package/dist/process/line-decoder.d.ts

@@ -0,0 +1,26 @@
+export type ProcessStream = "stdout" | "stderr";
+export type DecodedProcessRecord = {
+    kind: "output";
+    stream: ProcessStream;
+    text: string;
+    rejectedProbe?: boolean;
+} | {
+    kind: "probe-candidate";
+    stream: ProcessStream;
+    value: unknown;
+} | {
+    kind: "truncated";
+    stream: ProcessStream;
+    maximumBytes: number;
+};
+export declare class ProcessLineDecoder {
+    private readonly options;
+    private readonly streams;
+    constructor(options: {
+        maxLineBytes: number;
+    });
+    push(stream: ProcessStream, chunk: Buffer): DecodedProcessRecord[];
+    flush(stream: ProcessStream): DecodedProcessRecord[];
+    private consume;
+    private decodeLine;
+}

package/dist/process/protocol.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const ParentMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"start">;
+    executable: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+    cwd: z.ZodString;
+    env: z.ZodRecord<z.ZodString, z.ZodString>;
+    timeoutMs: z.ZodNumber;
+    ownerNonce: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"terminate">;
+    reason: z.ZodString;
+}, z.core.$strict>], "type">;
+export declare const ChildMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"ready">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"started">;
+    targetPid: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    targetPid: z.ZodNumber;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    signal: z.ZodNullable<z.ZodString>;
+    timedOut: z.ZodBoolean;
+    termination: z.ZodOptional<z.ZodObject<{
+        graceful: z.ZodBoolean;
+        forced: z.ZodBoolean;
+        remaining: z.ZodBoolean;
+        durationMs: z.ZodNumber;
+        errors: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"failure">;
+    code: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strict>], "type">;
+export type ParentMessage = z.infer<typeof ParentMessageSchema>;
+export type ChildMessage = z.infer<typeof ChildMessageSchema>;
+export declare function parseParentMessage(value: unknown): ParentMessage;
+export declare function parseChildMessage(value: unknown): ChildMessage;

package/dist/process/service.d.ts

@@ -0,0 +1,46 @@
+import type { Clock } from "../core/clock.js";
+import type { EvidenceStore } from "../evidence/store.js";
+import type { ProbeRegistry } from "../probes/registry.js";
+import type { RunService } from "../run/service.js";
+import type { DebugSession } from "../session/registry.js";
+export type ProcessCaptureInput = Readonly<{
+    runId: string;
+    executable: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+    timeoutMs: number;
+    probeIds?: string[];
+    purpose?: "instrumentation-check" | "reproduction" | "verification";
+    signal?: AbortSignal;
+}>;
+export type ProcessCaptureResult = Readonly<{
+    processId: string;
+    runId: string;
+    exitCode: number | null;
+    signal: string | null;
+    timedOut: boolean;
+    durationMs: number;
+    stdoutEvents: number;
+    stderrEvents: number;
+    probeEvents: number;
+}>;
+export declare class ProcessService {
+    private readonly dependencies;
+    constructor(dependencies: {
+        session: DebugSession;
+        runs: RunService;
+        evidence: EvidenceStore;
+        acquireLease: () => Promise<() => void>;
+        probes?: ProbeRegistry;
+        supervisorPath?: string;
+        clock?: Clock;
+    });
+    capture(input: ProcessCaptureInput): Promise<ProcessCaptureResult>;
+    private persistRecord;
+    private addOwnedProcess;
+    private markStarted;
+    private markCompleted;
+    private updateManifest;
+    private waitForMessage;
+}

package/dist/process/tree.d.ts

@@ -0,0 +1,16 @@
+export type Execute = (executable: string, args: string[]) => Promise<{
+    exitCode: number | null;
+}>;
+export type TerminationResult = Readonly<{
+    graceful: boolean;
+    forced: boolean;
+    remaining: boolean;
+    durationMs: number;
+    errors: string[];
+}>;
+export declare function terminateTree(targetPid: number, options?: {
+    platform?: NodeJS.Platform;
+    execute?: Execute;
+    gracefulMs?: number;
+    forceMs?: number;
+}): Promise<TerminationResult>;