oh-my-opencode-serverlocal 0.1.0

package/dist/interview/dashboard-manager.d.ts

@@ -0,0 +1,21 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+export declare function createDashboardManager(ctx: PluginInput, config: PluginConfig, dashboardPort: number, outputFolder: string): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    handleEvent: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+};

package/dist/interview/dashboard.d.ts

@@ -0,0 +1,67 @@
+import type { InterviewStateEntry } from './types';
+export declare function readDashboardAuthFile(port: number): Promise<{
+    token: string;
+    pid: number;
+    startedAt: number;
+} | null>;
+interface RegisteredSession {
+    sessionID: string;
+    directory: string;
+    pid: number;
+    registeredAt: number;
+}
+export declare const DEFAULT_DASHBOARD_PORT = 43211;
+export interface DashboardConfig {
+    port: number;
+    outputFolder: string;
+    sessionClient?: {
+        list: (params?: Record<string, unknown>) => Promise<{
+            data?: Array<{
+                directory?: string;
+                time?: {
+                    updated?: number;
+                };
+            }>;
+        }>;
+    };
+}
+export declare function createDashboardServer(config: DashboardConfig): {
+    start: () => Promise<string>;
+    close: () => void;
+    registerSession: (info: RegisteredSession) => void;
+    removeSession: (sessionID: string) => void;
+    pushState: (entry: InterviewStateEntry) => void;
+    getState: (interviewId: string) => InterviewStateEntry | undefined;
+    storeAnswers: (interviewId: string, answers: Array<{
+        questionId: string;
+        answer: string;
+    }>) => void;
+    getPendingAnswers: (interviewId: string) => Array<{
+        questionId: string;
+        answer: string;
+    }> | null;
+    consumePendingAnswers: (interviewId: string) => Array<{
+        questionId: string;
+        answer: string;
+    }> | null;
+    consumeNudgeAction: (interviewId: string) => 'more-questions' | 'confirm-complete' | null;
+    consumeBlockComment: (interviewId: string) => {
+        section: string;
+        comment: string;
+    } | null;
+    consumeChatMessage: (interviewId: string) => string | null;
+    authToken: string;
+    discoverSessionDirectories: () => Promise<void>;
+    addManualFolder: (dir: string) => void;
+    removeManualFolder: (dir: string) => void;
+    getManualFolders: () => string[];
+    setScanDays: (days: number) => void;
+    getScanDays: () => number;
+    refreshFiles: () => Promise<void>;
+};
+export declare function probeDashboard(port: number): Promise<{
+    alive: boolean;
+    timestamp: number;
+}>;
+export declare function tryBecomeDashboard(config: DashboardConfig, maxAttempts?: number): Promise<ReturnType<typeof createDashboardServer> | null>;
+export {};

package/dist/interview/document.d.ts

@@ -0,0 +1,29 @@
+import { parseFrontmatter as sharedParseFrontmatter } from '../utils/frontmatter';
+import type { InterviewAnswer, InterviewQuestion, InterviewRecord, SpecBlock } from './types';
+export declare const DEFAULT_OUTPUT_FOLDER = "interview";
+export declare function normalizeOutputFolder(outputFolder: string): string;
+export declare function createInterviewDirectoryPath(directory: string, outputFolder: string): string;
+export declare function createInterviewFilePath(directory: string, outputFolder: string, idea: string): string;
+export declare function relativeInterviewPath(directory: string, filePath: string): string;
+/**
+ * Resolve a user-provided value to an existing .md file path.
+ * Checks absolute paths, relative paths, and output-folder-relative paths.
+ * Returns null if no matching file is found.
+ */
+export declare function resolveExistingInterviewPath(directory: string, outputFolder: string, value: string): string | null;
+export declare function slugify(value: string): string;
+export declare function extractSummarySection(document: string): string;
+export declare function extractTitle(document: string): string;
+export declare function buildInterviewDocument(idea: string, summary: string, history: string, meta?: {
+    sessionID?: string;
+    baseMessageCount?: number;
+    owner?: string;
+    tags?: string[];
+}): string;
+/** Parse frontmatter from a .md file. Returns null if no frontmatter. */
+export declare const parseFrontmatter: typeof sharedParseFrontmatter;
+export declare function ensureInterviewFile(record: InterviewRecord): Promise<void>;
+export declare function readInterviewDocument(record: InterviewRecord): Promise<string>;
+export declare function rewriteInterviewDocument(record: InterviewRecord, summary: string): Promise<string>;
+export declare function appendInterviewAnswers(record: InterviewRecord, questions: InterviewQuestion[], answers: InterviewAnswer[]): Promise<void>;
+export declare function parseSpecBlocks(markdown: string): SpecBlock[];

package/dist/interview/helpers.d.ts

@@ -0,0 +1,10 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function sendJson(response: ServerResponse, status: number, value: unknown): void;
+export declare function sendHtml(response: ServerResponse, html: string): void;
+export declare function isValidId(id: string): boolean;
+export declare function extractResumeSlug(interviewId: string): string;
+/**
+ * Read and parse JSON body from an HTTP request with size limit.
+ * Destroys the request if the body exceeds MAX_BODY_SIZE.
+ */
+export declare function readJsonBody(request: IncomingMessage): Promise<unknown>;

package/dist/interview/index.d.ts

@@ -0,0 +1 @@
+export { createInterviewManager } from './manager';

package/dist/interview/manager.d.ts

@@ -0,0 +1,21 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+export declare function createInterviewManager(ctx: PluginInput, config: PluginConfig): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    handleEvent: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+};

package/dist/interview/parser.d.ts

@@ -0,0 +1,11 @@
+import type { InterviewAssistantState, InterviewMessage } from './types';
+export declare function flattenMessage(message: InterviewMessage): string;
+export declare function buildFallbackState(messages: InterviewMessage[]): InterviewAssistantState;
+export declare function parseAssistantState(text: string, maxQuestions?: number): {
+    state: InterviewAssistantState | null;
+    error?: string;
+};
+export declare function findLatestAssistantState(messages: InterviewMessage[], maxQuestions?: number): {
+    state: InterviewAssistantState | null;
+    latestAssistantError?: string;
+};

package/dist/interview/prompts.d.ts

@@ -0,0 +1,7 @@
+import type { InterviewQuestion } from './types';
+export declare function buildKickoffPrompt(idea: string, maxQuestions: number): string;
+export declare function buildResumePrompt(document: string, maxQuestions: number): string;
+export declare function buildAnswerPrompt(answers: Array<{
+    questionId: string;
+    answer: string;
+}>, questions: InterviewQuestion[], maxQuestions: number): string;

package/dist/interview/server.d.ts

@@ -0,0 +1,15 @@
+import type { InterviewAnswer, InterviewFileItem, InterviewListItem, InterviewState } from './types';
+export declare function createInterviewServer(deps: {
+    getState: (interviewId: string) => Promise<InterviewState>;
+    listInterviewFiles: () => Promise<InterviewFileItem[]>;
+    listInterviews: () => InterviewListItem[];
+    submitAnswers: (interviewId: string, answers: InterviewAnswer[]) => Promise<void>;
+    submitBlockComment: (interviewId: string, section: string, comment: string) => Promise<void>;
+    submitChat: (interviewId: string, message: string) => Promise<void>;
+    handleNudgeAction: (interviewId: string, action: 'more-questions' | 'confirm-complete') => Promise<void>;
+    outputFolder: string;
+    port: number;
+}): {
+    ensureStarted: () => Promise<string>;
+    close: () => void;
+};

package/dist/interview/service.d.ts

@@ -0,0 +1,45 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { InterviewConfig } from '../config';
+import type { InterviewAnswer, InterviewFileItem, InterviewListItem, InterviewRecord, InterviewState } from './types';
+/**
+ * Cap on retained abandoned interview records. Abandoned interviews are kept
+ * briefly so a still-open browser tab can render their final state, but
+ * without a bound the `interviewsById` and `browserOpened` collections grow
+ * for the life of a long-running session/dashboard process.
+ */
+export declare const MAX_RETAINED_ABANDONED = 50;
+export declare function createInterviewService(ctx: PluginInput, config?: InterviewConfig, deps?: {
+    openBrowser?: (url: string) => void;
+    env?: NodeJS.ProcessEnv;
+}): {
+    setBaseUrlResolver: (resolver: () => Promise<string>) => void;
+    setStatePushCallback: (callback: (interviewId: string, state: InterviewState) => void) => void;
+    setOnInterviewCreated: (callback: (interview: InterviewRecord) => void) => void;
+    getActiveInterviewId: (sessionID: string) => string | null;
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+            synthetic?: boolean;
+            metadata?: Record<string, unknown>;
+        }>;
+    }) => Promise<void>;
+    handleEvent: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+    getInterviewState: (interviewId: string) => Promise<InterviewState>;
+    listInterviewFiles: () => Promise<InterviewFileItem[]>;
+    listInterviews: () => InterviewListItem[];
+    submitAnswers: (interviewId: string, answers: InterviewAnswer[]) => Promise<void>;
+    submitBlockComment: (interviewId: string, section: string, comment: string) => Promise<void>;
+    submitChat: (interviewId: string, message: string) => Promise<void>;
+    handleNudgeAction: (interviewId: string, action: 'more-questions' | 'confirm-complete') => Promise<void>;
+};

package/dist/interview/session-server.d.ts

@@ -0,0 +1,21 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { InterviewConfig } from '../config';
+export declare function createPerSessionInterviewServer(ctx: PluginInput, interviewConfig: InterviewConfig | undefined, outputFolder: string): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    handleEvent: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+};

package/dist/interview/types.d.ts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+export interface InterviewQuestion {
+    id: string;
+    question: string;
+    options: string[];
+    suggested?: string;
+}
+export interface InterviewAnswer {
+    questionId: string;
+    answer: string;
+}
+export interface InterviewAssistantState {
+    summary: string;
+    title?: string;
+    questions: InterviewQuestion[];
+}
+/** Raw question object from LLM output - loose, everything optional. */
+export declare const RawQuestionSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    question: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    suggested: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/** Raw interview_state block from LLM output. */
+export declare const RawInterviewStateSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodOptional<z.ZodUnknown>;
+    questions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strip>;
+export interface InterviewRecord {
+    id: string;
+    sessionID: string;
+    idea: string;
+    markdownPath: string;
+    createdAt: string;
+    abandonedAt?: string;
+    abandonedOrder?: number;
+    status: 'active' | 'abandoned';
+    baseMessageCount: number;
+}
+export interface InterviewMessagePart {
+    type?: string;
+    text?: string;
+}
+export interface InterviewMessage {
+    info?: {
+        role?: string;
+        [key: string]: unknown;
+    };
+    parts?: InterviewMessagePart[];
+}
+export interface InterviewListItem {
+    id: string;
+    idea: string;
+    status: InterviewRecord['status'];
+    createdAt: string;
+}
+export interface InterviewFileItem {
+    fileName: string;
+    resumeCommand: string;
+    title: string;
+    summary: string;
+    sessionID?: string;
+    directory?: string;
+}
+export interface SpecBlock {
+    id: string;
+    title: string;
+    content: string;
+}
+export interface InterviewState {
+    interview: InterviewRecord;
+    url: string;
+    markdownPath: string;
+    mode: 'awaiting-agent' | 'awaiting-user' | 'abandoned' | 'completed' | 'error' | 'session-disconnected';
+    lastParseError?: string;
+    isBusy: boolean;
+    summary: string;
+    questions: InterviewQuestion[];
+    document: string;
+    blocks: SpecBlock[];
+}
+/** Wire format for dashboard state cache entries. */
+export interface InterviewStateEntry {
+    interviewId: string;
+    sessionID: string;
+    idea: string;
+    mode: 'awaiting-agent' | 'awaiting-user' | 'abandoned' | 'completed' | 'error' | 'session-disconnected';
+    summary: string;
+    title: string;
+    questions: Array<{
+        id: string;
+        question: string;
+        options?: string[];
+        suggested?: string;
+    }>;
+    pendingAnswers: Array<{
+        questionId: string;
+        answer: string;
+    }> | null;
+    lastUpdatedAt: number;
+    filePath: string;
+    nudgeAction: 'more-questions' | 'confirm-complete' | null;
+    pendingBlockComment: {
+        section: string;
+        comment: string;
+    } | null;
+    pendingChatMessage: string | null;
+    document?: string;
+    blocks?: SpecBlock[];
+}

package/dist/interview/ui.d.ts

@@ -0,0 +1,11 @@
+import type { InterviewFileItem, InterviewListItem } from './types';
+interface DashboardInterviewItem extends InterviewListItem {
+    url: string;
+    mode: string;
+    resumeSlug: string;
+    sessionID?: string;
+    directory?: string;
+}
+export declare function renderDashboardPage(interviews: DashboardInterviewItem[], files: InterviewFileItem[], outputFolder: string): string;
+export declare function renderInterviewPage(interviewId: string, resumeSlug: string): string;
+export {};

package/dist/loop/loop-session.d.ts

@@ -0,0 +1,64 @@
+export declare function loopDirname(loopID: string, goal: string): string;
+export type LoopPhase = 'executing' | 'verifying' | 'done' | 'escalated' | 'cancelled';
+export type ExecuteAgent = 'fixer' | 'designer' | 'explorer' | 'librarian';
+export type VerifyAgent = 'oracle' | 'observer' | 'test';
+export type SuccessCriterion = {
+    type: 'test';
+    command: string;
+} | {
+    type: 'build';
+    command: string;
+} | {
+    type: 'lint';
+    command: string;
+} | {
+    type: 'fileExists';
+    path: string;
+} | {
+    type: 'command';
+    command: string;
+    expectExitCode?: number;
+} | {
+    type: 'oracle';
+} | {
+    type: 'observer';
+} | {
+    type: 'manual';
+};
+export interface LoopDefinition {
+    goal: string;
+    successCriteria: string;
+    success: SuccessCriterion;
+    maxAttempts: number;
+    executeAgent: ExecuteAgent;
+    verifyAgent: VerifyAgent;
+    contextFiles?: string[];
+    parentSessionID?: string;
+}
+export type VerificationResult = {
+    passed: true;
+    reason: string;
+} | {
+    passed: false;
+    reason: string;
+    suggestedFix?: string;
+};
+export interface AttemptRecord {
+    attemptNumber: number;
+    executionResult: string;
+    verificationResult: VerificationResult;
+    artifactPaths?: string[];
+}
+export interface LoopSession {
+    loopID: string;
+    definition: LoopDefinition;
+    currentPhase: LoopPhase;
+    attempts: number;
+    activeJobID?: string;
+    history: AttemptRecord[];
+    historyDir: string;
+    manualReviewPending: boolean;
+}
+export declare function createLoopSession(definition: LoopDefinition, loopID: string): LoopSession;
+export declare function compactAttempt(attempt: AttemptRecord): string;
+export declare function writeHistoryFile(session: LoopSession): void;

package/dist/mcp/context7.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * Context7 - official documentation lookup for libraries
+ * @see https://context7.com
+ */
+export declare const context7: RemoteMcpConfig;

package/dist/mcp/grep-app.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * grep.app - ultra-fast code search across GitHub repositories
+ * @see https://grep.app
+ */
+export declare const gh_grep: RemoteMcpConfig;

package/dist/mcp/index.d.ts

@@ -0,0 +1,8 @@
+import type { WebsearchConfig } from '../config';
+import type { McpConfig } from './types';
+export type { LocalMcpConfig, McpConfig, RemoteMcpConfig } from './types';
+/**
+ * Creates MCP configurations, excluding disabled ones.
+ * Accepts an optional websearchConfig to override the default Exa provider.
+ */
+export declare function createBuiltinMcps(disabledMcps?: readonly string[], websearchConfig?: WebsearchConfig): Record<string, McpConfig>;

package/dist/mcp/types.d.ts

@@ -0,0 +1,12 @@
+export type RemoteMcpConfig = {
+    type: 'remote';
+    url: string;
+    headers?: Record<string, string>;
+    oauth?: false;
+};
+export type LocalMcpConfig = {
+    type: 'local';
+    command: string[];
+    environment?: Record<string, string>;
+};
+export type McpConfig = RemoteMcpConfig | LocalMcpConfig;

package/dist/mcp/websearch.d.ts

@@ -0,0 +1,9 @@
+import type { WebsearchConfig } from '../config';
+import type { RemoteMcpConfig } from './types';
+/**
+ * Creates a websearch MCP config based on the provided configuration.
+ * Supports Exa (default) and Tavily providers.
+ * @see https://exa.ai  @see https://tavily.com
+ */
+export declare function createWebsearchConfig(config?: WebsearchConfig): RemoteMcpConfig;
+export declare const websearch: RemoteMcpConfig;

package/dist/multiplexer/cmux/close-policy.d.ts

@@ -0,0 +1,20 @@
+export type CmuxCloseReason = 'idle' | 'deleted' | 'cleanup';
+export interface CmuxCloseIntent {
+    reason: CmuxCloseReason;
+    expectedActivityVersion: number;
+    attempts: number;
+    deadline: number;
+    phase: 'pending' | 'cooldown';
+    nextAttemptAt: number;
+    cooldowns: number;
+}
+export declare class CmuxClosePolicy {
+    private readonly budgetMs;
+    private readonly maxAttempts;
+    constructor(budgetMs?: number, maxAttempts?: number);
+    request(reason: CmuxCloseReason, version: number, now: number, current?: CmuxCloseIntent): CmuxCloseIntent;
+    activity(intent?: CmuxCloseIntent): CmuxCloseIntent | undefined;
+    failed(intent: CmuxCloseIntent, now: number): CmuxCloseIntent;
+    resume(intent: CmuxCloseIntent, now: number): CmuxCloseIntent;
+    complete(): undefined;
+}

package/dist/multiplexer/cmux/index.d.ts

@@ -0,0 +1,102 @@
+import type { MultiplexerLayout } from '../../config/schema';
+import { crossSpawn } from '../../utils/compat';
+import type { Multiplexer, PaneResult } from '../types';
+export interface CmuxReadinessOptions {
+    checkSessionReady?: (url: URL, sessionId: string, signal: AbortSignal) => Promise<boolean>;
+    delay?: (milliseconds: number) => Promise<void>;
+    readinessAttemptTimeoutMs?: number;
+    opencodeBinary?: string;
+    pathExists?: (path: string) => boolean;
+}
+export interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface CommandRunner {
+    run(argv: string[]): Promise<CommandResult>;
+}
+export interface CmuxIdentity {
+    workspaceId: string;
+    paneId: string;
+    surfaceId: string;
+    socketPath: string;
+}
+export interface CmuxClient {
+    version(): Promise<string | null>;
+    getVersionError?(): 'unavailable' | 'hard';
+    identify(): Promise<CmuxIdentity | null>;
+    getIdentifyError?(): 'unavailable' | 'hard';
+    createSurface(input: {
+        workspaceId: string;
+        targetSurfaceId: string;
+        direction: 'right' | 'down';
+        focus: false;
+    }, socketPath?: string): Promise<{
+        paneId: string;
+        surfaceId: string;
+    } | null>;
+    getCreateError?(): 'not_found' | 'unavailable' | 'invalid_state' | 'hard';
+    respawnSurface(workspaceId: string, surfaceId: string, command: string, socketPath?: string): Promise<boolean>;
+    closeSurface(workspaceId: string, surfaceId: string, socketPath?: string): Promise<'closed' | 'not_found' | 'failed'>;
+    equalizeSplits(params: {
+        workspace_id: string;
+        orientation: 'vertical';
+    }, socketPath?: string): Promise<boolean>;
+}
+export declare class CmuxMultiplexer implements Multiplexer {
+    private readonly client;
+    readonly type: "cmux";
+    private versionAvailable;
+    private availabilityError;
+    private readonly checkSessionReady;
+    private readonly delay;
+    private readonly readinessAttemptTimeoutMs;
+    private readonly opencodeBinary;
+    constructor(client?: CmuxClient, options?: CmuxReadinessOptions);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    spawnPane(sessionId: string, _description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(_layout: MultiplexerLayout, _mainPaneSize: number): Promise<void>;
+    private cleanupPane;
+    private waitForSession;
+    private equalize;
+}
+export declare class SpawnCommandRunner implements CommandRunner {
+    private readonly timeoutMs;
+    private readonly spawn;
+    constructor(timeoutMs?: number, spawn?: typeof crossSpawn);
+    run(argv: string[]): Promise<CommandResult>;
+}
+export declare class CliCmuxClient implements CmuxClient {
+    private readonly runner;
+    private binary;
+    private versionError;
+    private identifyError;
+    private lastRunThrew;
+    private createError;
+    constructor(runner?: CommandRunner, binary?: string);
+    version(): Promise<string | null>;
+    getVersionError(): 'unavailable' | 'hard';
+    identify(): Promise<CmuxIdentity | null>;
+    getIdentifyError(): 'unavailable' | 'hard';
+    createSurface(input: {
+        workspaceId: string;
+        targetSurfaceId: string;
+        direction: 'right' | 'down';
+        focus: false;
+    }, socketPath?: string): Promise<{
+        paneId: string;
+        surfaceId: string;
+    } | null>;
+    getCreateError(): 'not_found' | 'unavailable' | 'invalid_state' | 'hard';
+    respawnSurface(workspaceId: string, surfaceId: string, command: string, socketPath?: string): Promise<boolean>;
+    closeSurface(workspaceId: string, surfaceId: string, socketPath?: string): Promise<'closed' | 'not_found' | 'failed'>;
+    equalizeSplits(params: {
+        workspace_id: string;
+        orientation: 'vertical';
+    }, socketPath?: string): Promise<boolean>;
+    private run;
+}
+export declare function resetCmuxStateForTests(): void;