@deksden-com/dd-flow-cli 0.9.0-beta.134 → 0.9.0-beta.136

package/dist/harness-runtime/vendor/opencode-client/effect/generated/client.js

@@ -0,0 +1,8 @@
+import {
+  make3
+} from "../../chunks/service-probe-q4g3afnw.js";
+import"../../chunks/service-probe-y2etg5bs.js";
+import"../../chunks/service-probe-vmytr4q8.js";
+export {
+  make3 as make
+};

package/dist/harness-runtime/vendor/opencode-client/effect/generated/index.d.ts

@@ -0,0 +1,2 @@
+export { ClientError } from "./client-error.js";
+export * as OpenCode from "./client.js";

package/dist/harness-runtime/vendor/opencode-client/effect/generated/index.js

@@ -0,0 +1,12 @@
+import"../../chunks/service-probe-6mptkzbc.js";
+import {
+  exports_client2
+} from "../../chunks/service-probe-q4g3afnw.js";
+import {
+  ClientError2
+} from "../../chunks/service-probe-y2etg5bs.js";
+import"../../chunks/service-probe-vmytr4q8.js";
+export {
+  ClientError2 as ClientError,
+  exports_client2 as OpenCode
+};

package/dist/harness-runtime/vendor/opencode-client/effect/index.d.ts

@@ -0,0 +1,35 @@
+import type { Effect } from "effect";
+import type { OpenCode } from "./client.js";
+export * from "./generated/index";
+export { OpenCode } from "./client.js";
+export type { AgentApi, AppApi, CommandApi, ConfigApi, EventApi, IntegrationApi, ModelApi, PluginApi, ProviderApi, ReferenceApi, RpcApi, RpcClient, WebSearchApi, SessionApi, SkillApi, } from "./api.js";
+export { Agent } from "@opencode/schema/agent";
+export { Command } from "@opencode/schema/command";
+export { Config } from "@opencode/schema/config";
+export { Credential } from "@opencode/schema/credential";
+export { Event } from "@opencode/schema/event";
+export { EventLog } from "@opencode/schema/event-log";
+export { FileSystem } from "@opencode/schema/filesystem";
+export { Form } from "@opencode/schema/form";
+export { Integration } from "@opencode/schema/integration";
+export { Location } from "@opencode/schema/location";
+export { Model } from "@opencode/schema/model";
+export { Permission } from "@opencode/schema/permission";
+export { PermissionSaved } from "@opencode/schema/permission-saved";
+export { Project } from "@opencode/schema/project";
+export { Worktree } from "@opencode/schema/worktree";
+export { Vcs } from "@opencode/schema/vcs";
+export { Provider } from "@opencode/schema/provider";
+export { Pty } from "@opencode/schema/pty";
+export { Question } from "@opencode/schema/question";
+export { Reference } from "@opencode/schema/reference";
+export { WebSearch } from "@opencode/schema/websearch";
+export { AbsolutePath, RelativePath } from "@opencode/schema/schema";
+export { Session } from "@opencode/schema/session";
+export { SessionInbox } from "@opencode/schema/session-inbox";
+export { SessionMessage } from "@opencode/schema/session-message";
+export { Skill } from "@opencode/schema/skill";
+export { Prompt } from "@opencode/schema/prompt";
+export { PromptInput } from "@opencode/schema/prompt-input";
+export type { OpenCodeEvent } from "@opencode/protocol/groups/event";
+export type OpenCodeClient = Effect.Success<ReturnType<typeof OpenCode.make>>;

package/dist/harness-runtime/vendor/opencode-client/effect/index.js

@@ -0,0 +1,75 @@
+import {
+  ClientError2
+} from "../chunks/service-probe-y2etg5bs.js";
+import"../chunks/service-probe-vmytr4q8.js";
+import"../chunks/service-probe-q4g3afnw.js";
+import"../chunks/service-probe-6mptkzbc.js";
+import"../chunks/service-probe-frbwqjmf.js";
+import"../chunks/service-probe-t1xa31vm.js";
+import"../chunks/service-probe-z6qdwcsf.js";
+import {
+  exports_client
+} from "../chunks/service-probe-7x67cf1q.js";
+
+// src/effect/index.ts
+import { Agent } from "@opencode/schema/agent";
+import { Command } from "@opencode/schema/command";
+import { Config } from "@opencode/schema/config";
+import { Credential } from "@opencode/schema/credential";
+import { Event } from "@opencode/schema/event";
+import { EventLog } from "@opencode/schema/event-log";
+import { FileSystem } from "@opencode/schema/filesystem";
+import { Form } from "@opencode/schema/form";
+import { Integration } from "@opencode/schema/integration";
+import { Location } from "@opencode/schema/location";
+import { Model } from "@opencode/schema/model";
+import { Permission } from "@opencode/schema/permission";
+import { PermissionSaved } from "@opencode/schema/permission-saved";
+import { Project } from "@opencode/schema/project";
+import { Worktree } from "@opencode/schema/worktree";
+import { Vcs } from "@opencode/schema/vcs";
+import { Provider } from "@opencode/schema/provider";
+import { Pty } from "@opencode/schema/pty";
+import { Question } from "@opencode/schema/question";
+import { Reference } from "@opencode/schema/reference";
+import { WebSearch } from "@opencode/schema/websearch";
+import { AbsolutePath, RelativePath } from "@opencode/schema/schema";
+import { Session } from "@opencode/schema/session";
+import { SessionInbox } from "@opencode/schema/session-inbox";
+import { SessionMessage } from "@opencode/schema/session-message";
+import { Skill } from "@opencode/schema/skill";
+import { Prompt } from "@opencode/schema/prompt";
+import { PromptInput } from "@opencode/schema/prompt-input";
+export {
+  AbsolutePath,
+  Agent,
+  ClientError2 as ClientError,
+  Command,
+  Config,
+  Credential,
+  Event,
+  EventLog,
+  FileSystem,
+  Form,
+  Integration,
+  Location,
+  Model,
+  exports_client as OpenCode,
+  Permission,
+  PermissionSaved,
+  Project,
+  Prompt,
+  PromptInput,
+  Provider,
+  Pty,
+  Question,
+  Reference,
+  RelativePath,
+  Session,
+  SessionInbox,
+  SessionMessage,
+  Skill,
+  Vcs,
+  WebSearch,
+  Worktree
+};

package/dist/harness-runtime/vendor/opencode-client/effect/rpc.d.ts

@@ -0,0 +1,20 @@
+export * as RpcClientRuntime from "./rpc.js";
+import type { Rpc } from "@opencode/schema/rpc";
+import type { RpcError, RpcInternalError } from "@opencode/protocol/errors";
+import type { OpenCodeEvent } from "@opencode/protocol/groups/event";
+import { Effect, Schema, Stream } from "effect";
+import type { RpcArguments, RpcCallOptions } from "../promise/rpc.js";
+import type { RpcCallInput, RpcCallOutput } from "./api/api.js";
+type DecodeError<S> = S extends Schema.Top ? Schema.SchemaError : never;
+export type RpcClient<D extends Rpc.Definition, E = never, Options = RpcCallOptions, EventError = E> = {
+    readonly [Name in keyof D["methods"]]: (...args: RpcArguments<Rpc.Input<D["methods"][Name]["input"]>, Options>) => Effect.Effect<Rpc.Output<D["methods"][Name]["output"]>, Rpc.MethodError<D["methods"][Name]> | DecodeError<D["methods"][Name]["output"]> | E>;
+} & {
+    readonly events: {
+        readonly subscribe: <Name extends keyof D["events"] & string>(name: Name) => Stream.Stream<Rpc.EventPayload<D, Name>, DecodeError<D["events"][Name]["schema"]> | EventError>;
+    };
+};
+export interface RpcApi<E = never, Options = RpcCallOptions, EventError = E> {
+    <D extends Rpc.Definition>(definition: D): RpcClient<D, E, Options, EventError>;
+}
+export declare function make<CallError, EventError>(call: (input: RpcCallInput, options?: RpcCallOptions) => Effect.Effect<RpcCallOutput, CallError>, subscribe: () => Stream.Stream<OpenCodeEvent, EventError>): RpcApi<Exclude<CallError, RpcError | RpcInternalError> | Rpc.SystemError, RpcCallOptions, EventError>;
+export declare function aborted(signal: AbortSignal): Effect.Effect<void, never, never>;

package/dist/harness-runtime/vendor/opencode-client/effect/rpc.js

@@ -0,0 +1,11 @@
+import {
+  make4,
+  aborted2,
+  exports_rpc
+} from "../chunks/service-probe-z6qdwcsf.js";
+import"../chunks/service-probe-t1xa31vm.js";
+export {
+  exports_rpc as RpcClientRuntime,
+  aborted2 as aborted,
+  make4 as make
+};

package/dist/harness-runtime/vendor/opencode-client/effect/service.d.ts

@@ -0,0 +1,90 @@
+import { Effect, FileSystem, Schema } from "effect";
+import type { DiscoverOptions, EnsureOptions, StopOptions } from "../service.js";
+import { headers } from "../service-probe.js";
+export * from "../service.js";
+export { headers };
+/** Contents of the local service registration file. */
+export type Info = import("../service.js").Info;
+/** Discover a healthy, compatible local service without starting one. */
+export declare const discover: (options?: DiscoverOptions | undefined) => Effect.Effect<{
+    url: string;
+    auth: {
+        type: "basic";
+        username: string;
+        password: string;
+    } | undefined;
+} | undefined, never, FileSystem.FileSystem>;
+/** Recognize an authenticated compatible service bound to an expected URL, including while it starts or fails. */
+export declare const incumbent: (options: DiscoverOptions & {
+    readonly url: string;
+}) => Effect.Effect<{
+    endpoint: {
+        url: string;
+        auth: {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+    };
+    state: "failed" | "ready" | "waiting";
+} | undefined, never, FileSystem.FileSystem>;
+/** Ensure a healthy, compatible local service is running. */
+export declare const ensure: (options?: EnsureOptions | undefined) => Effect.Effect<{
+    url: string;
+    auth: {
+        type: "basic";
+        username: string;
+        password: string;
+    } | undefined;
+}, Error, FileSystem.FileSystem>;
+/** Stop the registered local service. */
+export declare const stop: (options?: StopOptions | undefined) => Effect.Effect<void, Error, FileSystem.FileSystem>;
+/** Schema for the local service registration file. */
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.optional<Schema.String>;
+    readonly version: Schema.optional<Schema.String>;
+    readonly url: Schema.String;
+    readonly pid: Schema.Int;
+    readonly password: Schema.optional<Schema.String>;
+}>;
+/** Effect-based local service lifecycle operations. */
+export declare const Service: {
+    discover: (options?: DiscoverOptions | undefined) => Effect.Effect<{
+        url: string;
+        auth: {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+    } | undefined, never, FileSystem.FileSystem>;
+    incumbent: (options: DiscoverOptions & {
+        readonly url: string;
+    }) => Effect.Effect<{
+        endpoint: {
+            url: string;
+            auth: {
+                type: "basic";
+                username: string;
+                password: string;
+            } | undefined;
+        };
+        state: "failed" | "ready" | "waiting";
+    } | undefined, never, FileSystem.FileSystem>;
+    ensure: (options?: EnsureOptions | undefined) => Effect.Effect<{
+        url: string;
+        auth: {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+    }, Error, FileSystem.FileSystem>;
+    stop: (options?: StopOptions | undefined) => Effect.Effect<void, Error, FileSystem.FileSystem>;
+    headers: typeof headers;
+    Info: Schema.Struct<{
+        readonly id: Schema.optional<Schema.String>;
+        readonly version: Schema.optional<Schema.String>;
+        readonly url: Schema.String;
+        readonly pid: Schema.Int;
+        readonly password: Schema.optional<Schema.String>;
+    }>;
+};

package/dist/harness-runtime/vendor/opencode-client/effect/service.js

@@ -0,0 +1,187 @@
+import {
+  spawnServiceContender2,
+  contenderPool2
+} from "../chunks/service-probe-ve4aws36.js";
+import {
+  defaultEnsureTiming2,
+  ensureTiming2
+} from "../chunks/service-probe-xgnj2w4v.js";
+import {
+  matchesVersion2
+} from "../chunks/service-probe-sxt88q69.js";
+import {
+  prepare2,
+  environment2,
+  complete2,
+  clear2
+} from "../chunks/service-probe-gx9wnkzr.js";
+import {
+  decide2,
+  fallback2,
+  same2,
+  probeResult2,
+  headers2
+} from "../chunks/service-probe-2ny4vxct.js";
+import"../chunks/service-probe-qav6mfdz.js";
+
+// src/effect/service.ts
+import { Effect, FileSystem, Option, Schedule, Schema } from "effect";
+var discover = Effect.fn("service.discover")(function* (options = {}) {
+  const found = (yield* registered(options.file)).service;
+  if (found?.state !== "ready")
+    return;
+  if (!found.compatible)
+    return;
+  if (!matchesVersion2(found.version, options))
+    return;
+  return found.endpoint;
+});
+var incumbent = Effect.fn("service.incumbent")(function* (options) {
+  const info = yield* read(options.file);
+  if (info === undefined)
+    return;
+  const found = (yield* Effect.promise(() => probeResult2({ ...info, url: options.url }))).service;
+  if (!found?.compatible)
+    return;
+  if (!matchesVersion2(found.version, options))
+    return;
+  return { endpoint: found.endpoint, state: found.state };
+});
+var ensure = Effect.fn("service.ensure")(function* (options = {}) {
+  const timing = ensureTiming2(options);
+  const pool = contenderPool2(timing);
+  let timeouts;
+  let announced = false;
+  const announce = (reason, previousVersion) => Effect.sync(() => {
+    if (announced)
+      return;
+    announced = true;
+    options.onStart?.(reason, previousVersion);
+  });
+  const spawnContender = Effect.gen(function* () {
+    const [command, ...args] = options.command ?? ["opencode", "serve", "--service"];
+    if (command === undefined)
+      return yield* Effect.fail(new Error("Missing service command"));
+    const env = yield* Effect.tryPromise(() => environment2(options.file ?? fallback2(), options.env));
+    return yield* Effect.try({
+      try: () => {
+        return spawnServiceContender2(command, args, env);
+      },
+      catch: (cause) => new Error("Failed to start server", { cause })
+    });
+  });
+  const found = yield* Effect.gen(function* () {
+    const registration = yield* registered(options.file, timing.requestTimeout);
+    const info = registration.info;
+    const service2 = registration.service;
+    if (registration.timedOut && info !== undefined) {
+      timeouts = {
+        info,
+        count: timeouts !== undefined && same2(timeouts.info, info) ? timeouts.count + 1 : 1
+      };
+      if (timeouts.count >= 3) {
+        yield* announce("missing");
+        yield* Effect.logWarning("Background service is unresponsive; recovery cannot preserve persistent terminals");
+        yield* Effect.tryPromise(() => clear2(options.file ?? fallback2()));
+        yield* terminate(info, options, timing);
+        pool.evict(info.pid);
+        pool.recruitNow();
+        timeouts = undefined;
+      }
+    } else
+      timeouts = undefined;
+    if (service2 !== undefined) {
+      pool.serviceAnswered();
+      const decision = decide2(service2, options);
+      if (decision._tag === "fail")
+        return yield* Effect.fail(decision.error);
+      if (decision._tag === "reuse") {
+        yield* Effect.tryPromise(() => complete2(options.file ?? fallback2(), service2.info));
+        return Option.some(service2);
+      }
+      if (decision._tag === "replace") {
+        yield* announce("version-mismatch", service2.version);
+        if (service2.state !== "ready")
+          yield* Effect.logWarning("Background service is not ready; replacement cannot preserve persistent terminals");
+        yield* stop({ file: options.file, pty: decision.pty }).pipe(Effect.ignore);
+        pool.evict(service2.info.pid);
+      }
+      return Option.none();
+    }
+    const failed = pool.reap();
+    if (failed !== undefined)
+      return yield* Effect.fail(failed);
+    if (pool.shouldRecruit(info !== undefined)) {
+      yield* announce("missing");
+      pool.add(yield* spawnContender);
+    }
+    return Option.none();
+  }).pipe(Effect.repeat({
+    until: Option.isSome,
+    schedule: Schedule.spaced(timing.pollInterval).pipe(Schedule.upTo({ duration: timing.promiseTimeout }))
+  }), Effect.ensuring(Effect.sync(() => pool.releaseAll())));
+  if (Option.isNone(found))
+    return yield* Effect.fail(pool.failure() ?? new Error("Timed out waiting for the background service to start"));
+  return found.value.endpoint;
+});
+var stop = Effect.fn("service.stop")(function* (options = {}) {
+  const info = yield* read(options.file);
+  yield* Effect.tryPromise(() => options.pty === "handoff" && info !== undefined ? prepare2(options.file ?? fallback2(), info, defaultEnsureTiming2.requestTimeout) : clear2(options.file ?? fallback2())).pipe(Effect.catch((cause) => Effect.logWarning("Failed to prepare persistent terminals for replacement", cause)));
+  if (info !== undefined)
+    yield* terminate(info, options, ensureTiming2(options));
+});
+var Info = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  version: Schema.optional(Schema.String),
+  url: Schema.String,
+  pid: Schema.Int.check(Schema.isGreaterThan(0)),
+  password: Schema.optional(Schema.String)
+});
+var decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Info));
+var read = Effect.fnUntraced(function* (file) {
+  const fs = yield* FileSystem.FileSystem;
+  const text = yield* fs.readFileString(file ?? fallback2()).pipe(Effect.option);
+  if (Option.isNone(text))
+    return;
+  return yield* decode(text.value).pipe(Effect.option, Effect.map(Option.getOrUndefined));
+});
+var registered = Effect.fnUntraced(function* (file, timeout) {
+  const info = yield* read(file);
+  if (info === undefined)
+    return { info: undefined, service: undefined, timedOut: false };
+  return { info, ...yield* Effect.promise(() => probeResult2(info, timeout)) };
+});
+var poll = (timing) => Schedule.max([Schedule.spaced(timing.stopPollInterval), Schedule.recurs(timing.stopPollAttempts)]);
+var signal = (pid, name) => Effect.try({ try: () => process.kill(pid, name), catch: (cause) => cause }).pipe(Effect.ignore);
+var stopped = Effect.fnUntraced(function* (pid) {
+  const running = yield* Effect.try({ try: () => process.kill(pid, 0), catch: () => false }).pipe(Effect.orElseSucceed(() => false));
+  if (!running)
+    return true;
+  return yield* Effect.fail(new Error(`Server process ${pid} is still running`));
+});
+var terminate = Effect.fnUntraced(function* (info, options, timing) {
+  const current = yield* read(options.file);
+  if (current === undefined || !same2(current, info))
+    return;
+  yield* signal(info.pid, "SIGTERM");
+  const done = yield* stopped(info.pid).pipe(Effect.retry(poll(timing)), Effect.option);
+  if (Option.isNone(done)) {
+    yield* signal(info.pid, "SIGKILL");
+    yield* stopped(info.pid).pipe(Effect.retry(poll(timing)));
+  }
+  const latest = yield* read(options.file);
+  if (latest === undefined || !same2(latest, info))
+    return;
+  const fs = yield* FileSystem.FileSystem;
+  yield* fs.remove(options.file ?? fallback2()).pipe(Effect.ignore);
+});
+var Service = { discover, incumbent, ensure, stop, headers: headers2, Info };
+export {
+  Info,
+  Service,
+  discover,
+  ensure,
+  headers2 as headers,
+  incumbent,
+  stop
+};

package/dist/harness-runtime/vendor/opencode-client/package.json

@@ -0,0 +1,84 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode/client",
+  "version": "2.0.28",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anomalyco/opencode.git",
+    "directory": "packages/client"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/promise/index.js",
+      "types": "./dist/promise/index.d.ts"
+    },
+    "./promise": {
+      "import": "./dist/promise/index.js",
+      "types": "./dist/promise/index.d.ts"
+    },
+    "./promise/api": {
+      "import": "./dist/promise/api.js",
+      "types": "./dist/promise/api.d.ts"
+    },
+    "./service": {
+      "import": "./dist/promise/service.js",
+      "types": "./dist/promise/service.d.ts"
+    },
+    "./solid": {
+      "import": "./dist/solid/index.js",
+      "types": "./dist/solid/index.d.ts"
+    },
+    "./effect": {
+      "import": "./dist/effect/index.js",
+      "types": "./dist/effect/index.d.ts"
+    },
+    "./effect/api": {
+      "import": "./dist/effect/api.js",
+      "types": "./dist/effect/api.d.ts"
+    },
+    "./effect/service": {
+      "import": "./dist/effect/service.js",
+      "types": "./dist/effect/service.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run script/build-package.ts",
+    "generate": "bun run script/build.ts",
+    "check:generated": "bun run generate && git diff --exit-code -- src/promise/generated src/effect/generated src/effect/api",
+    "test": "bun test --timeout 5000",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@opencode/schema": "2.0.28",
+    "@opencode/protocol": "2.0.28"
+  },
+  "peerDependencies": {
+    "effect": "4.0.1",
+    "solid-js": ">=1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "effect": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.1",
+    "@opencode/httpapi-codegen": "2.0.28",
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.4.0",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1",
+    "effect": "4.0.1",
+    "solid-js": "1.9.15"
+  }
+}

package/dist/harness-runtime/vendor/opencode-client/promise/api.d.ts

@@ -0,0 +1,21 @@
+import type { OpenCode } from "./client.js";
+type Client = ReturnType<typeof OpenCode.make>;
+export type { RpcApi, RpcCallOptions, RpcClient, RpcEventPayload } from "./rpc.js";
+export type AgentApi = Client["agent"];
+export type CommandApi = Client["command"];
+export type ConfigApi = Client["config"];
+export type CredentialApi = Client["credential"];
+export type EventApi = Client["event"];
+export type GenerateApi = Client["generate"];
+export type IntegrationApi = Client["integration"];
+export type McpApi = Client["mcp"];
+export type ModelApi = Client["model"];
+export type PluginApi = Client["plugin"];
+export type PermissionApi = Client["permission"];
+export type ProviderApi = Client["provider"];
+export type ReferenceApi = Client["reference"];
+export type WebSearchApi = Client["websearch"];
+export type SessionApi = Client["session"];
+export type SkillApi = Client["skill"];
+export type VcsApi = Client["vcs"];
+export type WorktreeApi = Client["worktree"];