@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-ppq9etn0.js

@@ -0,0 +1,325 @@
+import {
+  Service79
+} from "./repository-8m31s27t.js";
+import {
+  Service78
+} from "./repository-x6rcf4cj.js";
+import {
+  Service52
+} from "./repository-1bvekr7f.js";
+import {
+  userNotification2
+} from "./repository-fxbjtjnd.js";
+import {
+  SessionMessage2
+} from "./repository-gftt206x.js";
+import {
+  NotFoundError7,
+  PromptConflictError2,
+  SyntheticConflictError2,
+  CompactionConflictError2,
+  BusyError2,
+  InboxConflictError2
+} from "./repository-3x8gcmrs.js";
+import {
+  SessionEvent2
+} from "./repository-ec1grn59.js";
+import {
+  Service60
+} from "./repository-1n274c67.js";
+import {
+  Delivery2,
+  SyntheticPayload2,
+  Service50
+} from "./repository-0wjw63yk.js";
+import {
+  Service48
+} from "./repository-2fbr18f9.js";
+import {
+  prepare2
+} from "./repository-1jnd8eq9.js";
+import {
+  stage2,
+  clear2,
+  commit2
+} from "./repository-1tjfkw5v.js";
+import {
+  start2
+} from "./repository-a3n1dpj2.js";
+import {
+  get4
+} from "./repository-h90k734v.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/session.ts
+var exports_session2 = {};
+__export(exports_session2, {
+  Session: () => exports_session2,
+  make: () => make13
+});
+import { DateTime, Effect, Fiber, Scope } from "effect";
+import { Event } from "@opencode/schema/event";
+import { FSUtil } from "@opencode/util/fs-util";
+var make13 = Effect.fn("Session.make")(function* () {
+  const bus = yield* Service78;
+  const database = yield* Service79;
+  const store = yield* Service60;
+  const instances = yield* Service52;
+  const execution = yield* Service48;
+  const admission = yield* Service50;
+  const fs = yield* FSUtil.Service;
+  const scope = yield* Scope.Scope;
+  const get = Effect.fn("Session.get")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* new NotFoundError7({ sessionID });
+    return session;
+  });
+  const message = Effect.fn("Session.message")(function* (sessionID, messageID) {
+    const stored = yield* store.message(messageID);
+    return stored?.sessionID === sessionID ? stored.message : undefined;
+  });
+  const view = Effect.fn("Session.view")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (session.time.idle === undefined || input.idle > DateTime.toEpochMillis(session.time.idle) || session.time.viewed !== undefined && DateTime.toEpochMillis(session.time.viewed) >= input.idle)
+      return;
+    yield* bus.publish(SessionEvent2.Viewed, { sessionID, idle: input.idle });
+  });
+  const rename = Effect.fn("Session.rename")(function* (sessionID, input) {
+    yield* get(sessionID);
+    yield* bus.publish(SessionEvent2.Renamed, { sessionID, title: input.title });
+  });
+  const setPermissions = Effect.fn("Session.setPermissions")(function* (sessionID, input) {
+    yield* get(sessionID);
+    yield* bus.publish(SessionEvent2.PermissionsUpdated, { sessionID, permissions: input.permissions });
+  });
+  const switchAgent = Effect.fn("Session.switchAgent")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    yield* bus.publish(SessionEvent2.AgentSelected, { sessionID, agent: input.agent, previous: session.agent });
+  });
+  const switchModel = Effect.fn("Session.switchModel")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (session.model?.providerID === input.model.providerID && session.model.id === input.model.id && (session.model.variant ?? "default") === (input.model.variant ?? "default"))
+      return;
+    yield* bus.publish(SessionEvent2.ModelSelected, { sessionID, model: input.model, previous: session.model });
+  });
+  const mutatePending = (sessionID, inboxID, mutation) => mutation({ sessionID, id: inboxID }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => Effect.gen(function* () {
+    yield* get(sessionID);
+    return yield* new InboxConflictError2({ sessionID, inboxID });
+  })));
+  const inbox = Effect.fn("Session.inbox")(function* (sessionID) {
+    yield* get(sessionID);
+    return yield* admission.list(sessionID);
+  });
+  const cancelInbox = Effect.fn("Session.cancelInbox")((sessionID, inboxID) => mutatePending(sessionID, inboxID, admission.cancel), Effect.uninterruptible);
+  const steerInbox = Effect.fn("Session.steerInbox")(function* (sessionID, inboxID) {
+    yield* mutatePending(sessionID, inboxID, admission.steer);
+    yield* execution.wake(sessionID);
+  }, Effect.uninterruptible);
+  const queueInbox = Effect.fn("Session.queueInbox")((sessionID, inboxID) => mutatePending(sessionID, inboxID, admission.queue), Effect.uninterruptible);
+  const prompt = Effect.fn("Session.prompt")((sessionID, input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const session = yield* get(sessionID);
+    const messageID = input.id ?? SessionMessage2.ID.create();
+    const admitted = yield* Effect.gen(function* () {
+      const existing = yield* admission.reconcile({
+        id: messageID,
+        sessionID: session.id,
+        type: "user",
+        delivery: input.delivery ?? "steer"
+      });
+      if (existing)
+        return existing;
+      const item = yield* restore(prepare2({ session, messageID, input }).pipe(Effect.provideService(Service52, instances), Effect.provideService(FSUtil.Service, fs)));
+      if (session.revert)
+        yield* commit2(bus, session);
+      return yield* admission.admit({
+        id: messageID,
+        sessionID: session.id,
+        item
+      });
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new PromptConflictError2({ sessionID, messageID })));
+    if (input.resume !== false)
+      yield* execution.wake(sessionID);
+    return admitted;
+  })));
+  const shell = Effect.fn("Session.shell")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    const running = yield* Effect.gen(function* () {
+      const started = yield* start2({ session, command: input.command }).pipe(Effect.provideService(Service52, instances), Effect.tapError((error) => synthetic(sessionID, {
+        text: `User shell command failed to start:
+${input.command}
+
+${error.message}`,
+        description: input.command,
+        metadata: { source: "shell", state: "error" },
+        resume: false
+      })), Effect.orDie);
+      yield* bus.publish(SessionEvent2.Shell.Started, {
+        sessionID,
+        shell: started.info
+      }, { id: input.id });
+      const terminal = yield* started.result;
+      const preview = yield* started.output;
+      yield* bus.publish(SessionEvent2.Shell.Ended, {
+        sessionID,
+        shell: terminal.info,
+        output: preview
+      });
+      yield* synthetic(sessionID, {
+        ...userNotification2(terminal),
+        resume: false
+      }).pipe(Effect.catchTag("Session.NotFoundError", () => Effect.void), Effect.orDie);
+    }).pipe(Effect.forkIn(scope, { startImmediately: true }));
+    yield* Fiber.join(running);
+  });
+  const skill = Effect.fn("Session.skill")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    const skill = yield* get4({ session, skill: input.skill }).pipe(Effect.provideService(Service52, instances));
+    yield* bus.publish(SessionEvent2.Skill.Activated, {
+      sessionID,
+      id: skill.id,
+      name: skill.name,
+      text: skill.content
+    }, { id: input.id ? Event.ID.make(input.id.replace(/^msg_/, "evt_")) : undefined });
+    if (input.resume !== false)
+      yield* execution.resume(sessionID).pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid);
+  });
+  const compact = Effect.fn("Session.compact")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (session.revert)
+      yield* commit2(bus, session);
+    const inputID = input.id ?? SessionMessage2.ID.create();
+    const admitted = yield* admission.admitCompaction({
+      id: inputID,
+      sessionID,
+      delivery: input.delivery ?? "steer"
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new CompactionConflictError2({ sessionID, inputID })));
+    yield* execution.wake(sessionID);
+    return admitted;
+  });
+  const wait = Effect.fn("Session.wait")(function* (sessionID) {
+    yield* get(sessionID);
+    yield* execution.awaitIdle(sessionID);
+  });
+  const resume = Effect.fn("Session.resume")(function* (sessionID) {
+    yield* get(sessionID);
+    yield* execution.resume(sessionID);
+  });
+  const synthetic = Effect.fn("Session.synthetic")((sessionID, input) => Effect.uninterruptible(Effect.gen(function* () {
+    yield* get(sessionID);
+    const inputID = input.id ?? SessionMessage2.ID.create();
+    const admittedInput = {
+      type: "synthetic",
+      payload: SyntheticPayload2.make({
+        text: input.text,
+        description: input.description,
+        metadata: input.metadata
+      }),
+      delivery: Delivery2.make(input.delivery ?? "steer")
+    };
+    const admitted = yield* admission.admit({
+      id: inputID,
+      sessionID,
+      item: admittedInput
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new SyntheticConflictError2({ sessionID, inputID })));
+    if (input.resume !== false && !(yield* get(sessionID)).revert)
+      yield* execution.wake(sessionID);
+    return admitted;
+  })));
+  const interrupt = Effect.fn("Session.interrupt")((sessionID, options) => Effect.uninterruptible(execution.interrupt(sessionID, options)));
+  const stage = Effect.fn("Session.revert.stage")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError2({ sessionID });
+    return yield* stage2({ session, messageID: input.messageID, files: input.files }).pipe(Effect.provideService(Service52, instances), Effect.provideService(Service79, database), Effect.provideService(Service78, bus));
+  });
+  const clear = Effect.fn("Session.revert.clear")(function* (sessionID) {
+    const session = yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError2({ sessionID });
+    yield* clear2(session).pipe(Effect.provideService(Service52, instances), Effect.provideService(Service78, bus));
+    return yield* execution.wake(sessionID);
+  });
+  const commit = Effect.fn("Session.revert.commit")(function* (sessionID) {
+    const session = yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError2({ sessionID });
+    return yield* commit2(bus, session);
+  });
+  const revert = { stage, clear, commit };
+  const operations = {
+    get,
+    message,
+    view,
+    rename,
+    setPermissions,
+    switchAgent,
+    switchModel,
+    inbox,
+    prompt,
+    synthetic,
+    shell,
+    skill,
+    compact,
+    wait,
+    resume,
+    interrupt,
+    cancelInbox,
+    steerInbox,
+    queueInbox,
+    revert
+  };
+  const forSession = (sessionID) => {
+    const get = operations.get.bind(undefined, sessionID);
+    const message = operations.message.bind(undefined, sessionID);
+    const view = operations.view.bind(undefined, sessionID);
+    const rename = operations.rename.bind(undefined, sessionID);
+    const setPermissions = operations.setPermissions.bind(undefined, sessionID);
+    const switchAgent = operations.switchAgent.bind(undefined, sessionID);
+    const switchModel = operations.switchModel.bind(undefined, sessionID);
+    const inbox = operations.inbox.bind(undefined, sessionID);
+    const prompt = operations.prompt.bind(undefined, sessionID);
+    const synthetic = operations.synthetic.bind(undefined, sessionID);
+    const shell = operations.shell.bind(undefined, sessionID);
+    const skill = operations.skill.bind(undefined, sessionID);
+    const compact = operations.compact.bind(undefined, sessionID);
+    const wait = operations.wait.bind(undefined, sessionID);
+    const resume = operations.resume.bind(undefined, sessionID);
+    const interrupt = operations.interrupt.bind(undefined, sessionID);
+    const cancelInbox = operations.cancelInbox.bind(undefined, sessionID);
+    const steerInbox = operations.steerInbox.bind(undefined, sessionID);
+    const queueInbox = operations.queueInbox.bind(undefined, sessionID);
+    const stage = operations.revert.stage.bind(undefined, sessionID);
+    const clear = operations.revert.clear.bind(undefined, sessionID);
+    const commit = operations.revert.commit.bind(undefined, sessionID);
+    const revert = { stage, clear, commit };
+    return {
+      id: sessionID,
+      get,
+      message,
+      view,
+      rename,
+      setPermissions,
+      switchAgent,
+      switchModel,
+      inbox,
+      prompt,
+      synthetic,
+      shell,
+      skill,
+      compact,
+      wait,
+      resume,
+      interrupt,
+      cancelInbox,
+      steerInbox,
+      queueInbox,
+      revert
+    };
+  };
+  return { forSession };
+});
+
+export { make13, exports_session2 };

package/dist/chunks/repository-pvp1cs2e.js

@@ -0,0 +1,114 @@
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  root2
+} from "./repository-1g6ktzxp.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  Service58,
+  node62
+} from "./repository-ykpr0q7c.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/file-access.ts
+var exports_file_access = {};
+__export(exports_file_access, {
+  FileAccess: () => exports_file_access,
+  Kind: () => Kind2,
+  ResolveInput: () => ResolveInput2,
+  Service: () => Service19,
+  externalDirectoryPermission: () => externalDirectoryPermission2,
+  node: () => node23,
+  resolvePath: () => resolvePath2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { Array, Context, Effect, Layer, Schema } from "effect";
+import path from "path";
+var Kind2 = Schema.Literals(["file", "directory"]);
+var ResolveInput2 = Schema.Struct({
+  path: Schema.String,
+  kind: Kind2.pipe(Schema.optional)
+});
+var externalDirectoryPermission2 = (input) => ({
+  action: input.action,
+  resources: [input.resource],
+  save: [input.save]
+});
+
+class Service19 extends Context.Service()("@opencode/FileAccess") {
+}
+var resolvePath2 = (directory, input, home = Global.Path.home) => {
+  const normalized = FSUtil.windowsPath(input);
+  return path.resolve(directory, normalized === "~" ? home : normalized.startsWith("~/") || process.platform === "win32" && normalized.startsWith("~\\") ? path.join(home, normalized.slice(2)) : normalized);
+};
+var slash = (value) => value.replaceAll("\\", "/");
+var invocation = (context) => ({
+  sessionID: context.sessionID,
+  agent: context.agent,
+  source: { type: "tool", messageID: context.messageID, id: context.id }
+});
+var layer = Layer.effect(Service19, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* Service66;
+  const permission = yield* Service58;
+  const resolve = Effect.fn("FileAccess.resolve")(function* (input) {
+    const absolute = AbsolutePath2.make(resolvePath2(location.directory, input.path));
+    const worktree = path.resolve(location.project.directory);
+    const internal = FSUtil.contains(location.directory, absolute) || worktree !== path.parse(worktree).root && FSUtil.contains(worktree, absolute);
+    if (internal) {
+      return {
+        absolute,
+        resource: slash(path.relative(location.directory, absolute) || ".")
+      };
+    }
+    const type = input.kind === "directory" ? "Directory" : input.kind === "file" ? "File" : (yield* fs.stat(absolute).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.undefined)))?.type;
+    const directory = AbsolutePath2.make(type === "Directory" ? absolute : path.dirname(absolute));
+    return {
+      absolute,
+      resource: slash(absolute),
+      externalDirectory: {
+        action: "external_directory",
+        directory,
+        resource: slash(path.join(directory, "*")),
+        save: slash(path.join((yield* root2(fs, directory)) ?? directory, "*"))
+      }
+    };
+  });
+  const authorizeExternal = Effect.fn("FileAccess.authorizeExternal")(function* (targets, context, metadata) {
+    const external = Array.dedupeWith(targets.flatMap((target) => target.externalDirectory ? [target.externalDirectory] : []), (left, right) => left.resource === right.resource);
+    if (external.length === 0)
+      return;
+    yield* permission.assert({
+      action: "external_directory",
+      resources: external.map((item) => item.resource),
+      save: external.map((item) => item.save),
+      ...metadata === undefined ? {} : { metadata },
+      ...invocation(context)
+    });
+  });
+  const authorizeRead = Effect.fn("FileAccess.authorizeRead")(function* (file, context, options) {
+    const target = yield* resolve({ path: file, kind: options ? "file" : undefined });
+    const sibling = options && path.dirname(target.absolute) === path.dirname(options.siblingOf.absolute);
+    if (!sibling)
+      yield* authorizeExternal([target], context);
+    yield* permission.assert({
+      action: "read",
+      resources: [target.resource],
+      save: ["*"],
+      ...invocation(context)
+    });
+    return target;
+  });
+  return Service19.of({ resolve, authorizeExternal, authorizeRead });
+}));
+var node23 = makeLocationNode({ service: Service19, layer, deps: [FSUtil.node, node70, node62] });
+
+export { Kind2, ResolveInput2, externalDirectoryPermission2, Service19, resolvePath2, node23, exports_file_access };