@fkqfkq123/opencode-autopilot 0.1.0

package/dist/packages/runtime/src/state/human-action-service.js

@@ -0,0 +1,80 @@
+export class DefaultHumanActionService {
+    humanActionStore;
+    stateStore;
+    artifactEvaluator;
+    tickScheduler;
+    eventStore;
+    constructor(humanActionStore, stateStore, artifactEvaluator, tickScheduler, eventStore) {
+        this.humanActionStore = humanActionStore;
+        this.stateStore = stateStore;
+        this.artifactEvaluator = artifactEvaluator;
+        this.tickScheduler = tickScheduler;
+        this.eventStore = eventStore;
+    }
+    async answer(workflowId, answers) {
+        const current = await this.humanActionStore.getCurrent(workflowId);
+        if (current) {
+            await this.humanActionStore.markResponded(current.id);
+            await this.humanActionStore.markConsumed(current.id);
+        }
+        await this.artifactEvaluator.answerQuestions(workflowId, answers);
+        await this.stateStore.updateWorkflow(workflowId, {
+            status: "in_progress",
+        });
+        await this.stateStore.updateRuntime(workflowId, {
+            waitingHumanActionId: null,
+            refinementAttempts: 0,
+            refinementEscalationReason: null,
+        });
+        await this.eventStore.append({
+            workflowId,
+            type: "human_action.resolved",
+            at: new Date().toISOString(),
+            payload: { actionType: "need_answers" },
+        });
+        await this.tickScheduler.requestTick(workflowId, "human answered");
+    }
+    async approve(workflowId) {
+        const current = await this.humanActionStore.getCurrent(workflowId);
+        if (current) {
+            await this.humanActionStore.markResponded(current.id);
+            await this.humanActionStore.markConsumed(current.id);
+        }
+        await this.stateStore.updateWorkflow(workflowId, {
+            approved: true,
+            status: "pending",
+        });
+        await this.stateStore.updateRuntime(workflowId, {
+            waitingHumanActionId: null,
+        });
+        await this.eventStore.append({
+            workflowId,
+            type: "human_action.resolved",
+            at: new Date().toISOString(),
+            payload: { actionType: "need_approval" },
+        });
+        await this.tickScheduler.requestTick(workflowId, "human approved");
+    }
+    async resume(workflowId) {
+        const current = await this.humanActionStore.getCurrent(workflowId);
+        if (current) {
+            await this.humanActionStore.markResponded(current.id);
+            await this.humanActionStore.markConsumed(current.id);
+        }
+        await this.stateStore.updateWorkflow(workflowId, {
+            status: "pending",
+            blockReason: null,
+        });
+        await this.stateStore.updateRuntime(workflowId, {
+            waitingHumanActionId: null,
+            recoveryState: "idle",
+        });
+        await this.eventStore.append({
+            workflowId,
+            type: "human_action.resolved",
+            at: new Date().toISOString(),
+            payload: { actionType: "blocked" },
+        });
+        await this.tickScheduler.requestTick(workflowId, "manual resume");
+    }
+}

package/dist/packages/runtime/src/state/human-action-store.d.ts

@@ -0,0 +1,9 @@
+import type { HumanAction } from "../../../core/src/human-actions/human-action";
+import type { HumanActionRecord } from "../../../core/src/human-actions/human-action-record";
+export interface HumanActionStore {
+    create(action: HumanAction): Promise<HumanActionRecord>;
+    getCurrent(workflowId: string): Promise<HumanActionRecord | null>;
+    markPresented(actionId: string): Promise<void>;
+    markResponded(actionId: string): Promise<void>;
+    markConsumed(actionId: string): Promise<void>;
+}

package/dist/packages/runtime/src/state/human-action-store.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/runtime/src/state/workflow-state-store.d.ts

@@ -0,0 +1,11 @@
+import type { WorkflowRuntimeState } from "../../../core/src/state/workflow-runtime-state";
+import type { WorkflowState } from "../../../core/src/state/workflow-state";
+export interface WorkflowStateStore {
+    getWorkflow(workflowId: string): Promise<WorkflowState | null>;
+    saveWorkflow(state: WorkflowState): Promise<void>;
+    updateWorkflow(workflowId: string, patch: Partial<WorkflowState>): Promise<WorkflowState>;
+    listWorkflows?(): Promise<WorkflowState[]>;
+    getRuntime(workflowId: string): Promise<WorkflowRuntimeState | null>;
+    saveRuntime(state: WorkflowRuntimeState): Promise<void>;
+    updateRuntime(workflowId: string, patch: Partial<WorkflowRuntimeState>): Promise<WorkflowRuntimeState>;
+}

package/dist/packages/runtime/src/state/workflow-state-store.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/runtime/src/subtasks/noop-subtask-tracker.d.ts

@@ -0,0 +1,4 @@
+import type { SubtaskTracker } from "./subtask-tracker";
+export declare class NoopSubtaskTracker implements SubtaskTracker {
+    hasRunningSubtasks(_workflowId: string): Promise<boolean>;
+}

package/dist/packages/runtime/src/subtasks/noop-subtask-tracker.js

@@ -0,0 +1,5 @@
+export class NoopSubtaskTracker {
+    async hasRunningSubtasks(_workflowId) {
+        return false;
+    }
+}

package/dist/packages/runtime/src/subtasks/subtask-tracker.d.ts

@@ -0,0 +1,3 @@
+export interface SubtaskTracker {
+    hasRunningSubtasks(workflowId: string): Promise<boolean>;
+}

package/dist/packages/runtime/src/subtasks/subtask-tracker.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/runtime/src/workspace/workflow-workspace.d.ts

@@ -0,0 +1,31 @@
+import type { Phase } from "../../../core/src/state/phase";
+export interface WorkflowWorkspace {
+    baseDir(): string;
+    workflowsRoot(): string;
+    workflowConfigFile(): string;
+    workflowDir(workflowId: string): string;
+    artifactStateFile(workflowId: string): string;
+    humanActionFile(workflowId: string): string;
+    workflowStateFile(workflowId: string): string;
+    workflowRuntimeStateFile(workflowId: string): string;
+    sessionsFile(workflowId: string): string;
+    eventsFile(workflowId: string): string;
+    eventsIndexFile(workflowId: string): string;
+    phaseArtifactFile(workflowId: string, phase: Phase): string;
+}
+export declare class DefaultWorkflowWorkspace implements WorkflowWorkspace {
+    private readonly root;
+    constructor(root: string);
+    baseDir(): string;
+    workflowsRoot(): string;
+    workflowConfigFile(): string;
+    workflowDir(workflowId: string): string;
+    artifactStateFile(workflowId: string): string;
+    humanActionFile(workflowId: string): string;
+    workflowStateFile(workflowId: string): string;
+    workflowRuntimeStateFile(workflowId: string): string;
+    sessionsFile(workflowId: string): string;
+    eventsFile(workflowId: string): string;
+    eventsIndexFile(workflowId: string): string;
+    phaseArtifactFile(workflowId: string, phase: Phase): string;
+}

package/dist/packages/runtime/src/workspace/workflow-workspace.js

@@ -0,0 +1,43 @@
+import { join } from "node:path";
+export class DefaultWorkflowWorkspace {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    baseDir() {
+        return this.root;
+    }
+    workflowsRoot() {
+        return join(this.root, "workflows");
+    }
+    workflowConfigFile() {
+        return join(this.root, "workflow.json");
+    }
+    workflowDir(workflowId) {
+        return join(this.workflowsRoot(), workflowId);
+    }
+    artifactStateFile(workflowId) {
+        return join(this.workflowDir(workflowId), "artifact-state.json");
+    }
+    humanActionFile(workflowId) {
+        return join(this.workflowDir(workflowId), "human-action.json");
+    }
+    workflowStateFile(workflowId) {
+        return join(this.workflowDir(workflowId), "workflow-state.json");
+    }
+    workflowRuntimeStateFile(workflowId) {
+        return join(this.workflowDir(workflowId), "workflow-runtime-state.json");
+    }
+    sessionsFile(workflowId) {
+        return join(this.workflowDir(workflowId), "sessions.json");
+    }
+    eventsFile(workflowId) {
+        return join(this.workflowDir(workflowId), "events.ndjson");
+    }
+    eventsIndexFile(workflowId) {
+        return join(this.workflowDir(workflowId), "events.json");
+    }
+    phaseArtifactFile(workflowId, phase) {
+        return join(this.workflowDir(workflowId), `${phase}.md`);
+    }
+}

package/dist/plugin.d.ts

@@ -0,0 +1 @@
+export { workflowPlugin as default } from "./packages/runtime/src/plugin/workflow-plugin-entry";

package/dist/plugin.js

@@ -0,0 +1 @@
+export { workflowPlugin as default } from "./packages/runtime/src/plugin/workflow-plugin-entry";

package/dist/src/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/cli.js

@@ -0,0 +1,175 @@
+import { join } from "node:path";
+import { createHarness } from "../packages/runtime/src/bootstrap/create-harness";
+import { initializeWorkflow } from "../packages/runtime/src/bootstrap/initialize-workflow";
+import { DefaultWorkflowCommandRunner } from "../packages/runtime/src/commands/default-workflow-command-runner";
+import { formatWorkflowDoctorResult, formatWorkflowInstallResult } from "../packages/runtime/src/diagnostics/workflow-diagnostics-format";
+import { runWorkflowDoctor } from "../packages/runtime/src/diagnostics/workflow-doctor";
+import { runWorkflowInstall } from "../packages/runtime/src/install/workflow-installer";
+import { renderHumanActionBlock } from "../packages/runtime/src/presentation/human-action-renderer";
+import { renderWatchFrame } from "../packages/runtime/src/presentation/watch-renderer";
+import { homedir } from "node:os";
+const WORKFLOW_COMMANDS = new Set([
+    "workflow-open",
+    "workflow-attach",
+    "workflow-status",
+    "workflow-answer",
+    "workflow-approve",
+    "workflow-resume",
+    "workflow-back",
+    "workflow-doctor",
+    "workflow-install",
+]);
+function normalizeCommand(command) {
+    if (!WORKFLOW_COMMANDS.has(command)) {
+        return command;
+    }
+    switch (command) {
+        case "workflow-open":
+            return "start";
+        case "workflow-attach":
+            return "attach";
+        case "workflow-status":
+            return "status";
+        case "workflow-answer":
+            return "answer";
+        case "workflow-approve":
+            return "approve";
+        case "workflow-resume":
+            return "resume";
+        case "workflow-back":
+            return "back";
+        case "workflow-doctor":
+            return "doctor";
+        case "workflow-install":
+            return "install";
+        default:
+            return command;
+    }
+}
+async function printSnapshot(harness, workflowId) {
+    const workflow = await harness.stateStore.getWorkflow(workflowId);
+    const runtime = await harness.stateStore.getRuntime(workflowId);
+    const humanAction = await harness.humanActionStore.getCurrent(workflowId);
+    if (!workflow) {
+        throw new Error(`Workflow not found: ${workflowId}`);
+    }
+    console.log(renderHumanActionBlock({ workflow, runtime, humanAction }));
+}
+async function watchWorkflow(harness, workflowId) {
+    await harness.attachService.attach(workflowId);
+    let lastFingerprint = "";
+    while (true) {
+        const workflow = await harness.stateStore.getWorkflow(workflowId);
+        const runtime = await harness.stateStore.getRuntime(workflowId);
+        const humanAction = await harness.humanActionStore.getCurrent(workflowId);
+        if (!workflow) {
+            throw new Error(`Workflow not found: ${workflowId}`);
+        }
+        const events = await harness.eventStore.list(workflowId);
+        const fingerprint = JSON.stringify({
+            workflow,
+            runtime,
+            humanAction,
+            eventCount: events.length,
+        });
+        if (fingerprint !== lastFingerprint) {
+            console.clear();
+            console.log(renderWatchFrame({
+                workflow,
+                runtime,
+                humanAction,
+                recentEvents: events,
+                attached: true,
+                modeLabel: "Autopilot",
+            }));
+            lastFingerprint = fingerprint;
+        }
+        if (workflow.phase === "done" || workflow.phase === "blocked") {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+}
+async function main() {
+    const [, , command, workflowId, payload] = process.argv;
+    const normalizedCommand = command ? normalizeCommand(command) : command;
+    const baseDir = join(process.cwd(), ".workflow-harness");
+    const harnessOptions = {
+        ...(process.env.OPENCODE_BASE_URL ? { opencodeBaseUrl: process.env.OPENCODE_BASE_URL } : {}),
+        ...(process.env.OPENCODE_SERVER_PASSWORD
+            ? { opencodePassword: process.env.OPENCODE_SERVER_PASSWORD }
+            : {}),
+    };
+    const harness = await createHarness(baseDir, harnessOptions);
+    const commandRunner = new DefaultWorkflowCommandRunner();
+    if (!normalizedCommand) {
+        throw new Error("Usage: bun run cli <start|status|watch|attach|answer|approve|resume|doctor|install|workflow-open|workflow-attach|workflow-status|workflow-answer|workflow-approve|workflow-resume|workflow-back|workflow-doctor|workflow-install> <workflowId> [payload]");
+    }
+    if (normalizedCommand === "install") {
+        const result = await runWorkflowInstall({
+            cwd: process.cwd(),
+            homeDir: homedir(),
+        });
+        console.log(formatWorkflowInstallResult(result));
+        return;
+    }
+    if (normalizedCommand === "doctor") {
+        const result = await runWorkflowDoctor(harness.workspace);
+        console.log(formatWorkflowDoctorResult(result));
+        return;
+    }
+    if (!workflowId) {
+        throw new Error("Usage: bun run cli <start|status|watch|attach|answer|approve|resume|doctor|workflow-open|workflow-attach|workflow-status|workflow-answer|workflow-approve|workflow-resume|workflow-back|workflow-doctor|workflow-install> <workflowId> [payload]");
+    }
+    if (normalizedCommand === "start") {
+        await initializeWorkflow({
+            workflowId,
+            stateStore: harness.stateStore,
+            artifactEvaluator: harness.artifactEvaluator,
+        });
+        await harness.sessionActivityMonitor.start(workflowId);
+        await harness.tickScheduler.requestTick(workflowId, "workflow started");
+    }
+    else if (normalizedCommand === "status") {
+        await printSnapshot(harness, workflowId);
+        return;
+    }
+    else if (normalizedCommand === "watch") {
+        await watchWorkflow(harness, workflowId);
+        return;
+    }
+    else if (normalizedCommand === "attach") {
+        await watchWorkflow(harness, workflowId);
+        return;
+    }
+    else if (WORKFLOW_COMMANDS.has(command)) {
+        const commandArgs = {
+            harness,
+            command: command,
+            workflowId,
+            ...(payload !== undefined ? { payload } : {}),
+        };
+        const result = await commandRunner.run(commandArgs);
+        console.log(result.output);
+        return;
+    }
+    else if (normalizedCommand === "back") {
+        console.log(`Returned from workflow channel for ${workflowId}. Your workflow continues and can be re-attached later.`);
+        return;
+    }
+    else if (normalizedCommand === "answer") {
+        const answers = payload ? JSON.parse(payload) : {};
+        await harness.humanActionService.answer(workflowId, answers);
+    }
+    else if (normalizedCommand === "approve") {
+        await harness.humanActionService.approve(workflowId);
+    }
+    else if (normalizedCommand === "resume") {
+        await harness.humanActionService.resume(workflowId);
+    }
+    else {
+        throw new Error(`Unknown command: ${command}`);
+    }
+    await printSnapshot(harness, workflowId);
+}
+void main();

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@fkqfkq123/opencode-autopilot",
+  "private": false,
+  "version": "0.1.0",
+  "type": "module",
+  "packageManager": "bun@1.3.5",
+  "main": "./dist/plugin.js",
+  "module": "./dist/plugin.js",
+  "types": "./dist/plugin.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
+    },
+    "./cli": {
+      "types": "./dist/src/cli.d.ts",
+      "import": "./dist/src/cli.js"
+    },
+    "./runtime": {
+      "types": "./dist/packages/runtime/src/index.d.ts",
+      "import": "./dist/packages/runtime/src/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:release": "bun run scripts/build-release.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "bun test",
+    "cli": "bun run src/cli.ts",
+    "smoke:plugin": "bun run scripts/plugin-smoke-test.ts",
+    "smoke:install": "bun run scripts/install-smoke-test.ts",
+    "prepublishOnly": "bun run typecheck && bun test && bun run build"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.4",
+    "@types/node": "22.13.9",
+    "typescript": "5.8.2"
+  },
+  "dependencies": {
+    "zod": "4.1.8"
+  },
+  "keywords": [
+    "workflow",
+    "opencode",
+    "plugin",
+    "agent",
+    "harness"
+  ]
+}