@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-g0he3e83.js

@@ -0,0 +1,574 @@
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Key3,
+  Service66,
+  node71
+} from "./worktree-0tg2xvbt.js";
+import {
+  create3
+} from "./worktree-kg06axw8.js";
+import {
+  validateAnswer2,
+  validateFields2
+} from "./worktree-rjbw5qw4.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/integration.ts
+var exports_integration = {};
+__export(exports_integration, {
+  Attempt: () => Attempt2,
+  AttemptID: () => AttemptID2,
+  AttemptStatus: () => AttemptStatus2,
+  AuthorizationError: () => AuthorizationError2,
+  CodeRequiredError: () => CodeRequiredError2,
+  CommandAttempt: () => CommandAttempt2,
+  CommandAttemptStatus: () => CommandAttemptStatus2,
+  CommandMethod: () => CommandMethod2,
+  EnvMethod: () => EnvMethod2,
+  Event: () => Event14,
+  ID: () => ID8,
+  Info: () => Info22,
+  Integration: () => exports_integration,
+  KeyMethod: () => KeyMethod2,
+  Method: () => Method2,
+  MethodID: () => MethodID2,
+  OAuthMethod: () => OAuthMethod2,
+  Ref: () => Ref2,
+  Service: () => Service64,
+  node: () => node69
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import {
+  Cause,
+  Clock,
+  Context,
+  Duration,
+  Effect,
+  Exit,
+  Fiber,
+  Layer,
+  Schedule,
+  Schema,
+  Scope,
+  Stream,
+  SynchronizedRef
+} from "effect";
+import { Integration } from "@opencode/schema/integration";
+import { AppProcess } from "@opencode/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { Event as Event14 } from "@opencode/schema/integration";
+var ID8 = Integration.ID;
+var MethodID2 = Integration.MethodID;
+var AttemptID2 = Integration.AttemptID;
+var OAuthMethod2 = Integration.OAuthMethod;
+var CommandMethod2 = Integration.CommandMethod;
+var KeyMethod2 = Integration.KeyMethod;
+var EnvMethod2 = Integration.EnvMethod;
+var Method2 = Integration.Method;
+var Info22 = Integration.Info;
+var Attempt2 = Integration.Attempt;
+var AttemptStatus2 = Integration.AttemptStatus;
+var CommandAttempt2 = Integration.CommandAttempt;
+var CommandAttemptStatus2 = Integration.CommandAttemptStatus;
+
+class CodeRequiredError2 extends Schema.TaggedError()("Integration.CodeRequired", {
+  attemptID: AttemptID2
+}) {
+}
+
+class AuthorizationError2 extends Schema.TaggedError()("Integration.Authorization", {
+  cause: Schema.Defect()
+}) {
+}
+var Ref2 = Integration.Ref;
+
+class Service64 extends Context.Service()("@opencode/Integration") {
+}
+var attemptLifetime = Duration.toMillis(Duration.minutes(10));
+var terminalRetention = Duration.toMillis(Duration.minutes(1));
+var scrubInterval = Duration.seconds(30);
+var layer = Layer.effect(Service64, Effect.gen(function* () {
+  const credentials = yield* Service66;
+  const bus = yield* Service79;
+  const processes = yield* AppProcess.Service;
+  const scope = yield* Scope.Scope;
+  const attempts = SynchronizedRef.makeUnsafe(new Map);
+  const commandAttempts = SynchronizedRef.makeUnsafe(new Map);
+  const state = create3({
+    name: "integration",
+    initial: () => ({ integrations: new Map }),
+    editor: (editor) => ({
+      list: () => Array.from(editor.integrations.values(), (entry) => entry.ref),
+      get: (id) => editor.integrations.get(id)?.ref,
+      update: (id, update) => {
+        const current = editor.integrations.get(id) ?? {
+          ref: { id, name: id },
+          methods: [],
+          implementations: new Map
+        };
+        if (!editor.integrations.has(id))
+          editor.integrations.set(id, current);
+        update(current.ref);
+        current.ref.id = id;
+      },
+      remove: (id) => editor.integrations.delete(id),
+      method: {
+        list: (integrationID) => editor.integrations.get(integrationID)?.methods ?? [],
+        update: (implementation) => {
+          const current = editor.integrations.get(implementation.integrationID) ?? {
+            ref: {
+              id: implementation.integrationID,
+              name: implementation.integrationID
+            },
+            methods: [],
+            implementations: new Map
+          };
+          if (!editor.integrations.has(implementation.integrationID)) {
+            editor.integrations.set(implementation.integrationID, current);
+          }
+          const index = current.methods.findIndex((method) => {
+            if (method.type !== implementation.method.type)
+              return false;
+            if (method.type === "oauth" && implementation.method.type === "oauth")
+              return method.id === implementation.method.id;
+            if (method.type === "command" && implementation.method.type === "command")
+              return method.id === implementation.method.id;
+            return true;
+          });
+          if (index === -1)
+            current.methods.push(implementation.method);
+          else
+            current.methods[index] = implementation.method;
+          if (implementation.method.type === "oauth") {
+            current.implementations.set(implementation.method.id, implementation);
+          }
+        },
+        remove: (integrationID, method) => {
+          const current = editor.integrations.get(integrationID);
+          if (!current)
+            return;
+          const index = current.methods.findIndex((candidate) => {
+            if (candidate.type !== method.type)
+              return false;
+            if (candidate.type === "oauth" && method.type === "oauth")
+              return candidate.id === method.id;
+            if (candidate.type === "command" && method.type === "command")
+              return candidate.id === method.id;
+            return true;
+          });
+          if (index !== -1)
+            current.methods.splice(index, 1);
+          if (method.type === "oauth")
+            current.implementations.delete(method.id);
+        }
+      }
+    }),
+    notify: () => bus.publish(Integration.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const createCredential = Effect.fnUntraced(function* (input) {
+    if (input.label !== undefined)
+      return yield* credentials.create(input);
+    const name = state.get().integrations.get(input.integrationID)?.ref.name ?? input.integrationID;
+    const labels = new Set((yield* credentials.list(input.integrationID)).map((credential) => credential.label));
+    const label = Array.from({ length: labels.size + 1 }, (_, index) => index === 0 ? name : `${name} ${index + 1}`).find((candidate) => !labels.has(candidate)) ?? name;
+    return yield* credentials.create({ ...input, label });
+  });
+  const resolveConnections = (entry, saved) => {
+    const credentials = saved.map((credential) => ({
+      type: "credential",
+      id: credential.id,
+      label: credential.label
+    })).toReversed();
+    const env = (entry?.methods ?? []).filter((method) => method.type === "env").flatMap((method) => method.names.filter((name) => process.env[name])).map((name) => ({ type: "env", name }));
+    return [...credentials, ...env];
+  };
+  const project = (entry, connections) => Info22.make({
+    id: entry.ref.id,
+    name: entry.ref.name,
+    ...entry.ref.metadata === undefined ? {} : { metadata: entry.ref.metadata },
+    methods: entry.methods,
+    connections
+  });
+  const authorize = (effect) => effect.pipe(Effect.mapError((cause) => new AuthorizationError2({ cause })));
+  const close = (attemptScope) => Scope.close(attemptScope, Exit.void).pipe(Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid);
+  const message = (cause) => {
+    const error = Cause.squash(cause);
+    return error instanceof Error ? error.message : String(error);
+  };
+  const settle = Effect.fnUntraced(function* (attemptID, exit) {
+    const now = yield* Clock.currentTimeMillis;
+    const attempt = yield* SynchronizedRef.modify(attempts, (current) => {
+      const match = current.get(attemptID);
+      if (!match || match.status !== "pending" || match.persisting)
+        return [undefined, current];
+      const next = Exit.isSuccess(exit) ? { ...match, persisting: true } : {
+        status: "failed",
+        integrationID: match.integrationID,
+        message: message(exit.cause),
+        time: match.time,
+        removeAt: now + terminalRetention
+      };
+      return [match, new Map(current).set(attemptID, next)];
+    });
+    if (!attempt)
+      return;
+    if (Exit.isFailure(exit)) {
+      yield* close(attempt.scope);
+      return;
+    }
+    yield* Effect.gen(function* () {
+      const persistence = yield* Effect.suspend(() => {
+        const implementation = state.get().integrations.get(attempt.integrationID)?.implementations.get(attempt.methodID);
+        return createCredential({
+          integrationID: attempt.integrationID,
+          label: attempt.label ?? implementation?.label?.(exit.value),
+          value: exit.value
+        });
+      }).pipe(Effect.asVoid, Effect.exit);
+      const settledAt = yield* Clock.currentTimeMillis;
+      const terminal = Exit.isSuccess(persistence) ? {
+        status: "complete",
+        integrationID: attempt.integrationID,
+        time: attempt.time,
+        removeAt: settledAt + terminalRetention
+      } : {
+        status: "failed",
+        integrationID: attempt.integrationID,
+        message: message(persistence.cause),
+        time: attempt.time,
+        removeAt: settledAt + terminalRetention
+      };
+      yield* SynchronizedRef.update(attempts, (current) => new Map(current).set(attemptID, terminal));
+      yield* persistence;
+    }).pipe(Effect.ensuring(close(attempt.scope)));
+  }, Effect.uninterruptible);
+  const settleCommand = Effect.fnUntraced(function* (attemptID, exit) {
+    const now = yield* Clock.currentTimeMillis;
+    const attempt = yield* SynchronizedRef.modify(commandAttempts, (current) => {
+      const match = current.get(attemptID);
+      if (!match || match.status !== "pending" || match.persisting)
+        return [undefined, current];
+      const next = Exit.isSuccess(exit) ? { ...match, persisting: true } : {
+        status: "failed",
+        integrationID: match.integrationID,
+        message: message(exit.cause),
+        time: match.time,
+        removeAt: now + terminalRetention
+      };
+      return [match, new Map(current).set(attemptID, next)];
+    });
+    if (!attempt)
+      return;
+    if (Exit.isFailure(exit)) {
+      yield* close(attempt.scope);
+      return;
+    }
+    const persistence = yield* createCredential({
+      integrationID: attempt.integrationID,
+      label: attempt.label,
+      value: Key3.make({ type: "key", key: exit.value })
+    }).pipe(Effect.asVoid, Effect.exit);
+    const settledAt = yield* Clock.currentTimeMillis;
+    const terminal = Exit.isSuccess(persistence) ? {
+      status: "complete",
+      integrationID: attempt.integrationID,
+      time: attempt.time,
+      removeAt: settledAt + terminalRetention
+    } : {
+      status: "failed",
+      integrationID: attempt.integrationID,
+      message: message(persistence.cause),
+      time: attempt.time,
+      removeAt: settledAt + terminalRetention
+    };
+    yield* SynchronizedRef.update(commandAttempts, (current) => new Map(current).set(attemptID, terminal));
+    yield* close(attempt.scope);
+  }, Effect.uninterruptible);
+  const scrub = Effect.fnUntraced(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    const expired = yield* SynchronizedRef.modify(attempts, (current) => {
+      const next = new Map(current);
+      const scopes = [];
+      for (const [id, attempt] of current) {
+        if (attempt.status === "pending" && !attempt.persisting && attempt.time.expires <= now) {
+          scopes.push(attempt.scope);
+          next.set(id, {
+            status: "expired",
+            integrationID: attempt.integrationID,
+            time: attempt.time,
+            removeAt: now + terminalRetention
+          });
+          continue;
+        }
+        if (attempt.status !== "pending" && attempt.removeAt <= now)
+          next.delete(id);
+      }
+      return [scopes, next];
+    });
+    yield* Effect.forEach(expired, close, { discard: true });
+  });
+  const scrubCommands = Effect.fnUntraced(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    const expired = yield* SynchronizedRef.modify(commandAttempts, (current) => {
+      const next = new Map(current);
+      const scopes = [];
+      for (const [id, attempt] of current) {
+        if (attempt.status === "pending" && !attempt.persisting && attempt.time.expires <= now) {
+          scopes.push(attempt.scope);
+          next.set(id, {
+            status: "expired",
+            integrationID: attempt.integrationID,
+            time: attempt.time,
+            removeAt: now + terminalRetention
+          });
+          continue;
+        }
+        if (attempt.status !== "pending" && attempt.removeAt <= now)
+          next.delete(id);
+      }
+      return [scopes, next];
+    });
+    yield* Effect.forEach(expired, close, { discard: true });
+  });
+  yield* scrub().pipe(Effect.repeat(Schedule.spaced(scrubInterval)), Effect.forkIn(scope));
+  yield* scrubCommands().pipe(Effect.repeat(Schedule.spaced(scrubInterval)), Effect.forkIn(scope));
+  const connectOAuth = Effect.fn("Integration.oauth.connect")(function* (input) {
+    const method = state.get().integrations.get(input.integrationID)?.implementations.get(input.methodID);
+    if (!method) {
+      return yield* Effect.die(new Error(`OAuth method not found: ${input.integrationID}/${input.methodID}`));
+    }
+    const answer = input.answer ?? {};
+    if (method.method.form) {
+      const invalid = validateFields2(method.method.form) ?? validateAnswer2(method.method.form, answer);
+      if (invalid)
+        return yield* new AuthorizationError2({ cause: new Error(invalid) });
+    }
+    const attemptScope = yield* Scope.fork(scope);
+    const authorization = yield* authorize(method.authorize(answer)).pipe(Scope.provide(attemptScope), Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(attemptScope, exit) : Effect.void));
+    const id = AttemptID2.create();
+    const created = yield* Clock.currentTimeMillis;
+    const time = { created, expires: authorization.expiresAt ?? created + attemptLifetime };
+    yield* SynchronizedRef.update(attempts, (current) => new Map(current).set(id, {
+      status: "pending",
+      completing: authorization.mode === "auto",
+      persisting: false,
+      authorization,
+      integrationID: input.integrationID,
+      methodID: input.methodID,
+      label: input.label,
+      scope: attemptScope,
+      time
+    }));
+    if (authorization.mode === "auto") {
+      yield* authorization.callback.pipe(Effect.exit, Effect.flatMap((exit) => settle(id, exit)), Effect.forkIn(attemptScope, { startImmediately: true }));
+    }
+    return new Attempt2({
+      attemptID: id,
+      url: authorization.url,
+      instructions: authorization.instructions,
+      mode: authorization.mode,
+      time
+    });
+  });
+  const connectCommand = Effect.fn("Integration.command.connect")(function* (input) {
+    const method = state.get().integrations.get(input.integrationID)?.methods.find((method) => method.type === "command" && method.id === input.methodID);
+    if (!method || method.type !== "command" || !method.command[0]) {
+      return yield* Effect.die(new Error(`Command method not found: ${input.integrationID}/${input.methodID}`));
+    }
+    const attemptScope = yield* Scope.fork(scope);
+    const attemptID = AttemptID2.create();
+    const created = yield* Clock.currentTimeMillis;
+    const time = { created, expires: created + attemptLifetime };
+    yield* SynchronizedRef.update(commandAttempts, (current) => new Map(current).set(attemptID, {
+      status: "pending",
+      integrationID: input.integrationID,
+      label: input.label,
+      persisting: false,
+      scope: attemptScope,
+      time
+    }));
+    yield* Effect.gen(function* () {
+      const handle = yield* processes.spawn(ChildProcess.make(method.command[0], method.command.slice(1), {
+        extendEnv: true,
+        stdin: "ignore"
+      }));
+      const stdout = yield* AppProcess.collectStream(handle.stdout, undefined).pipe(Effect.forkScoped);
+      yield* handle.stderr.pipe(Stream.decodeText, Stream.tap((chunk) => SynchronizedRef.update(commandAttempts, (current) => {
+        const attempt = current.get(attemptID);
+        if (!attempt || attempt.status !== "pending")
+          return current;
+        const message = (attempt.message ?? "") + chunk;
+        return new Map(current).set(attemptID, { ...attempt, message });
+      })), Stream.runDrain);
+      const exitCode = yield* handle.exitCode;
+      if (exitCode !== 0) {
+        const attempt = (yield* SynchronizedRef.get(commandAttempts)).get(attemptID);
+        return yield* Effect.fail(new Error(attempt?.message?.trim() || `Authentication command exited ${exitCode}`));
+      }
+      const credential = (yield* Fiber.join(stdout)).buffer.toString("utf8").trim();
+      if (!credential)
+        return yield* Effect.fail(new Error("Authentication command returned no credential"));
+      return credential;
+    }).pipe(Scope.provide(attemptScope), Effect.exit, Effect.flatMap((exit) => settleCommand(attemptID, exit)), Effect.forkIn(attemptScope, { startImmediately: true }));
+    return CommandAttempt2.make({ attemptID, time });
+  });
+  return Service64.of({
+    transform: state.transform,
+    reload: state.reload,
+    get: Effect.fn("Integration.get")(function* (id) {
+      const entry = state.get().integrations.get(id);
+      if (!entry)
+        return;
+      return project(entry, resolveConnections(entry, yield* credentials.list(id)));
+    }),
+    list: Effect.fn("Integration.list")(function* () {
+      const saved = Map.groupBy(yield* credentials.all(), (credential) => credential.integrationID);
+      return Array.from(state.get().integrations.values(), (entry) => project(entry, resolveConnections(entry, saved.get(entry.ref.id) ?? []))).toSorted((a, b) => a.name.localeCompare(b.name));
+    }),
+    connection: {
+      active: Effect.fn("Integration.connection.active")(function* (id) {
+        const entry = state.get().integrations.get(id);
+        return resolveConnections(entry, yield* credentials.list(id))[0];
+      }),
+      resolve: Effect.fn("Integration.connection.resolve")(function* (connection) {
+        if (connection.type === "env") {
+          const key = process.env[connection.name];
+          return key ? Key3.make({ type: "key", key }) : undefined;
+        }
+        const credential = yield* credentials.get(connection.id);
+        if (!credential)
+          return;
+        if (credential.value.type === "key")
+          return credential.value;
+        const implementation = state.get().integrations.get(credential.integrationID)?.implementations.get(credential.value.methodID);
+        if (!implementation?.refresh)
+          return credential.value;
+        const now = yield* Clock.currentTimeMillis;
+        if (credential.value.expires > now + Duration.toMillis(Duration.minutes(5)))
+          return credential.value;
+        const value = yield* authorize(implementation.refresh(credential.value));
+        yield* credentials.update(credential.id, { value });
+        return value;
+      }),
+      key: Effect.fn("Integration.connection.key")(function* (input) {
+        const method = state.get().integrations.get(input.integrationID)?.methods.find((method) => method.type === "key");
+        if (!method)
+          return yield* Effect.die(new Error(`Key method not found: ${input.integrationID}`));
+        const answer = input.answer ?? {};
+        if (method.form) {
+          const invalid = validateFields2(method.form) ?? validateAnswer2(method.form, answer);
+          if (invalid)
+            return yield* new AuthorizationError2({ cause: new Error(invalid) });
+        }
+        if (!method.form && Object.keys(answer).length > 0) {
+          return yield* new AuthorizationError2({ cause: new Error("Key method does not accept a form answer") });
+        }
+        yield* createCredential({
+          integrationID: input.integrationID,
+          label: input.label,
+          value: Key3.make({
+            type: "key",
+            key: input.key,
+            ...Object.keys(answer).length > 0 ? { configuration: answer } : {}
+          })
+        });
+      }),
+      activate: Effect.fn("Integration.connection.activate")((credentialID) => credentials.activate(credentialID)),
+      update: Effect.fn("Integration.connection.update")((credentialID, updates) => credentials.update(credentialID, updates)),
+      remove: Effect.fn("Integration.connection.remove")((credentialID) => credentials.remove(credentialID))
+    },
+    oauth: {
+      connect: connectOAuth,
+      status: Effect.fn("Integration.oauth.status")(function* (input) {
+        const attempt = (yield* SynchronizedRef.get(attempts)).get(input.attemptID);
+        if (!attempt || attempt.integrationID !== input.integrationID)
+          return yield* Effect.die(new Error(`OAuth attempt not found: ${input.attemptID}`));
+        if (attempt.status === "failed") {
+          return { status: attempt.status, message: attempt.message ?? "Authorization failed", time: attempt.time };
+        }
+        return { status: attempt.status, time: attempt.time };
+      }),
+      complete: Effect.fn("Integration.oauth.complete")(function* (input) {
+        const attempt = yield* SynchronizedRef.modify(attempts, (current) => {
+          const match = current.get(input.attemptID);
+          if (!match || match.integrationID !== input.integrationID)
+            return [undefined, current];
+          if (match.status !== "pending" || match.completing)
+            return [match, current];
+          if (match.authorization.mode === "code" && input.code === undefined)
+            return [match, current];
+          return [match, new Map(current).set(input.attemptID, { ...match, completing: true })];
+        });
+        if (!attempt)
+          return yield* Effect.die(new Error(`OAuth attempt not found: ${input.attemptID}`));
+        if (attempt.status !== "pending")
+          return;
+        if (attempt.authorization.mode === "code" && input.code === undefined) {
+          return yield* new CodeRequiredError2({ attemptID: input.attemptID });
+        }
+        if (attempt.completing)
+          return yield* Effect.die(new Error(`OAuth attempt already completing: ${input.attemptID}`));
+        const callback = attempt.authorization.mode === "auto" ? attempt.authorization.callback : attempt.authorization.callback(input.code);
+        const exit = yield* authorize(callback).pipe(Effect.exit);
+        yield* settle(input.attemptID, exit);
+        if (Exit.isFailure(exit))
+          return yield* exit;
+      }),
+      cancel: Effect.fn("Integration.oauth.cancel")(function* (input) {
+        const attempt = yield* SynchronizedRef.modify(attempts, (current) => {
+          const match = current.get(input.attemptID);
+          if (!match || match.integrationID !== input.integrationID || match.status !== "pending" || match.persisting)
+            return [undefined, current];
+          const next = new Map(current);
+          next.delete(input.attemptID);
+          return [match, next];
+        });
+        if (attempt)
+          yield* Scope.close(attempt.scope, Exit.void);
+      })
+    },
+    command: {
+      connect: connectCommand,
+      status: Effect.fn("Integration.command.status")(function* (input) {
+        const attempt = (yield* SynchronizedRef.get(commandAttempts)).get(input.attemptID);
+        if (!attempt || attempt.integrationID !== input.integrationID)
+          return yield* Effect.die(new Error(`Command attempt not found: ${input.attemptID}`));
+        if (attempt.status === "pending") {
+          return {
+            status: attempt.status,
+            ...attempt.message ? { message: attempt.message } : {},
+            time: attempt.time
+          };
+        }
+        if (attempt.status === "failed") {
+          return { status: attempt.status, message: attempt.message ?? "Authentication failed", time: attempt.time };
+        }
+        return { status: attempt.status, time: attempt.time };
+      }),
+      cancel: Effect.fn("Integration.command.cancel")(function* (input) {
+        const attempt = yield* SynchronizedRef.modify(commandAttempts, (current) => {
+          const match = current.get(input.attemptID);
+          if (!match || match.integrationID !== input.integrationID || match.status !== "pending" || match.persisting)
+            return [undefined, current];
+          const next = new Map(current);
+          next.delete(input.attemptID);
+          return [match, next];
+        });
+        if (attempt)
+          yield* Scope.close(attempt.scope, Exit.void);
+      })
+    }
+  });
+}));
+var node69 = makeLocationNode({
+  service: Service64,
+  layer,
+  deps: [node71, node84, AppProcess.node]
+});
+
+export { ID8, MethodID2, AttemptID2, OAuthMethod2, CommandMethod2, KeyMethod2, EnvMethod2, Method2, Info22, Attempt2, AttemptStatus2, CommandAttempt2, CommandAttemptStatus2, CodeRequiredError2, AuthorizationError2, Ref2, Service64, node69, exports_integration, Event14 };

package/dist/chunks/worktree-g190xswt.js

@@ -0,0 +1,41 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/v1/config/permission.ts
+var exports_permission = {};
+__export(exports_permission, {
+  Action: () => Action2,
+  ConfigPermissionV1: () => exports_permission,
+  Info: () => Info16,
+  Object: () => Object2,
+  Rule: () => Rule2
+});
+import { Schema, SchemaGetter } from "effect";
+var Action2 = Schema.Literals(["ask", "allow", "deny"]).annotate({ identifier: "PermissionActionConfig" });
+var Object2 = Schema.Record(Schema.String, Action2).annotate({ identifier: "PermissionObjectConfig" });
+var Rule2 = Schema.Union([Action2, Object2]).annotate({ identifier: "PermissionRuleConfig" });
+var InputObject = Schema.StructWithRest(Schema.Struct({
+  read: Schema.optional(Rule2),
+  edit: Schema.optional(Rule2),
+  glob: Schema.optional(Rule2),
+  grep: Schema.optional(Rule2),
+  list: Schema.optional(Rule2),
+  bash: Schema.optional(Rule2),
+  task: Schema.optional(Rule2),
+  external_directory: Schema.optional(Rule2),
+  question: Schema.optional(Action2),
+  webfetch: Schema.optional(Rule2),
+  websearch: Schema.optional(Action2),
+  lsp: Schema.optional(Rule2),
+  doom_loop: Schema.optional(Action2),
+  skill: Schema.optional(Rule2)
+}), [Schema.Record(Schema.String, Rule2)]);
+var InputSchema = Schema.Union([Action2, InputObject]);
+var normalizeInput = (input) => typeof input === "string" ? { "*": input } : input;
+var Info16 = InputSchema.pipe(Schema.decodeTo(InputObject, {
+  decode: SchemaGetter.transform(normalizeInput),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "PermissionConfig" });
+
+export { Action2, Object2, Rule2, Info16, exports_permission };

package/dist/chunks/worktree-g4wezp1m.js

@@ -0,0 +1,14 @@
+// src/github-copilot/chat/get-response-metadata.ts
+function getResponseMetadata2({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined
+  };
+}
+
+export { getResponseMetadata2 };

package/dist/chunks/worktree-g86h250q.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260303231226_add_workspace_fields.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260303231226_add_workspace_fields",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`type\` text NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`name\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`directory\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`extra\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` DROP COLUMN \`config\`;`);
+    });
+  }
+};
+var _20260303231226_add_workspace_fields_default = migration;
+
+export { _20260303231226_add_workspace_fields_default };