@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-1e2ryyac.js

@@ -0,0 +1,42 @@
+import {
+  exports_project
+} from "./permission-j2hktz7g.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/location.ts
+var exports_location = {};
+__export(exports_location, {
+  response: () => response,
+  node: () => node,
+  boundNode: () => boundNode,
+  Service: () => Service,
+  Ref: () => Ref,
+  Location: () => exports_location,
+  Info: () => Info
+});
+import { Context, Effect, Layer } from "effect";
+import { Info, Ref, response } from "@opencode-ai/schema/location";
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+import { makeLocationNode, tags } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/Location") {
+}
+var node = LayerNode.unbound(Service, tags.values.location);
+var layer = (ref) => Layer.effect(Service, Effect.gen(function* () {
+  const project = yield* exports_project.Service;
+  const resolved = yield* project.resolve(ref.directory);
+  return Service.of({
+    directory: ref.directory,
+    workspaceID: ref.workspaceID,
+    project: { id: resolved.id, directory: resolved.directory, canonical: resolved.canonical },
+    vcs: resolved.vcs
+  });
+}));
+var boundNode = (ref) => makeLocationNode({
+  service: Service,
+  layer: layer(ref),
+  deps: [exports_project.node]
+});
+
+export { Info, Ref, response, Service, node, boundNode, exports_location };

package/dist/chunks/permission-1fb7bmpf.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260511173437_session-metadata.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260511173437_session-metadata",
+  up(tx) {
+    return Effect.gen(function* () {
+      if ((yield* tx.all(`PRAGMA table_info(\`session\`)`)).some((column) => column.name === "metadata"))
+        return;
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`metadata\` text;`);
+    });
+  }
+};
+var _20260511173437_session_metadata_default = migration;
+
+export { _20260511173437_session_metadata_default };

package/dist/chunks/permission-1kvtxahz.js

@@ -0,0 +1,175 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/repository.ts
+var exports_repository = {};
+__export(exports_repository, {
+  validateBranch: () => validateBranch,
+  same: () => same,
+  parseRemote: () => parseRemote,
+  parse: () => parse,
+  isRemote: () => isRemote,
+  isFile: () => isFile,
+  cachePath: () => cachePath,
+  cacheIdentity: () => cacheIdentity,
+  UnsupportedLocalRepositoryError: () => UnsupportedLocalRepositoryError,
+  Repository: () => exports_repository,
+  InvalidReferenceError: () => InvalidReferenceError,
+  InvalidBranchError: () => InvalidBranchError
+});
+import path from "path";
+import { fileURLToPath } from "url";
+import { Schema } from "effect";
+
+class InvalidReferenceError extends Schema.TaggedErrorClass()("RepositoryInvalidReferenceError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class UnsupportedLocalRepositoryError extends Schema.TaggedErrorClass()("RepositoryUnsupportedLocalRepositoryError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class InvalidBranchError extends Schema.TaggedErrorClass()("RepositoryInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+function parse(input) {
+  const cleaned = normalizeInput(input);
+  if (!cleaned)
+    return;
+  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/);
+  if (githubPrefixed)
+    return buildRemote({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] });
+  if (!cleaned.includes("://")) {
+    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+    if (scp)
+      return buildRemote({ host: scp[1], segments: parts(scp[2]), remote: cleaned });
+    const direct = parts(cleaned);
+    if (direct.length >= 2 && hostLike(direct[0]))
+      return buildRemote({ host: direct[0], segments: direct.slice(1) });
+    if (direct.length === 2)
+      return buildRemote({ host: "github.com", segments: direct });
+  }
+  try {
+    const url = new URL(cleaned);
+    if (url.protocol === "file:")
+      return buildFile({ url, remote: cleaned });
+    const segments = parts(url.pathname);
+    return buildRemote({
+      host: url.host,
+      segments,
+      remote: url.host === "github.com" ? githubRemote(segments.join("/")) : cleaned,
+      protocol: url.protocol
+    });
+  } catch {
+    return;
+  }
+}
+function parseRemote(input) {
+  const reference = parse(input);
+  if (!reference) {
+    throw new InvalidReferenceError({
+      repository: input,
+      message: "Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand"
+    });
+  }
+  if (!isRemote(reference)) {
+    throw new UnsupportedLocalRepositoryError({
+      repository: input,
+      message: "Local file repositories are not supported"
+    });
+  }
+  return reference;
+}
+function validateBranch(branch) {
+  if (/^[A-Za-z0-9/_.-]+$/.test(branch) && !branch.startsWith("-") && !branch.includes(".."))
+    return;
+  throw new InvalidBranchError({
+    branch,
+    message: "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain .."
+  });
+}
+function isFile(reference) {
+  return reference.protocol === "file:";
+}
+function isRemote(reference) {
+  return !isFile(reference);
+}
+function cachePath(root, reference, branch) {
+  const base = path.join(root, ...reference.host.split(":"), ...reference.segments);
+  return branch ? `${base}@${encodeURIComponent(branch)}` : base;
+}
+function cacheIdentity(reference) {
+  return `${reference.host}/${reference.path}`;
+}
+function same(left, right) {
+  return cacheIdentity(left) === cacheIdentity(right);
+}
+function normalizeInput(input) {
+  return input.trim().replace(/^git\+/, "").replace(/#.*$/, "").replace(/\/+$/, "");
+}
+function trimGitSuffix(input) {
+  return input.replace(/\.git$/, "");
+}
+function parts(input) {
+  return input.split("/").map((item) => trimGitSuffix(item.trim())).filter(Boolean);
+}
+function safeHost(input) {
+  return Boolean(input) && !input.startsWith("-") && !/[\s/\\]/.test(input);
+}
+function safeSegment(input) {
+  return input !== "." && input !== ".." && !input.includes(":") && !/[\s/\\]/.test(input);
+}
+function hostLike(input) {
+  return input.includes(".") || input.includes(":") || input === "localhost";
+}
+function withSlash(input) {
+  return input.endsWith("/") ? input : `${input}/`;
+}
+function githubRemote(pathname) {
+  const base = process.env.OPENCODE_REPO_CLONE_GITHUB_BASE_URL;
+  if (!base)
+    return `https://github.com/${pathname}.git`;
+  return new URL(`${pathname}.git`, withSlash(base)).href;
+}
+function buildRemote(input) {
+  const segments = input.segments.map(trimGitSuffix).filter(Boolean);
+  if (!safeHost(input.host) || !segments.length || segments.some((segment) => !safeSegment(segment)))
+    return;
+  const repositoryPath = segments.join("/");
+  const host = input.host.toLowerCase();
+  return {
+    host,
+    path: repositoryPath,
+    segments,
+    owner: segments.length === 2 ? segments[0] : undefined,
+    repo: segments[segments.length - 1],
+    remote: input.remote ?? (host === "github.com" ? githubRemote(repositoryPath) : `https://${host}/${repositoryPath}.git`),
+    label: host === "github.com" && segments.length === 2 ? repositoryPath : `${host}/${repositoryPath}`,
+    protocol: input.protocol
+  };
+}
+function buildFile(input) {
+  const filePath = path.normalize(fileURLToPath(input.url));
+  const segments = filePath.split(/[\\/]+/).filter(Boolean);
+  if (!segments.length)
+    return;
+  return {
+    host: "file",
+    path: filePath,
+    segments: segments.map((segment) => segment.replace(/:$/, "")),
+    owner: undefined,
+    repo: trimGitSuffix(segments[segments.length - 1]),
+    remote: input.remote,
+    label: filePath,
+    protocol: "file:"
+  };
+}
+
+export { InvalidReferenceError, UnsupportedLocalRepositoryError, InvalidBranchError, parse, parseRemote, validateBranch, isFile, isRemote, cachePath, cacheIdentity, same, exports_repository };

package/dist/chunks/permission-1q4v9p9k.js

@@ -0,0 +1,70 @@
+import {
+  PermissionTable
+} from "./permission-nesb2rcz.js";
+import {
+  exports_project
+} from "./permission-j2hktz7g.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/permission/saved.ts
+var exports_saved = {};
+__export(exports_saved, {
+  node: () => node,
+  Service: () => Service,
+  PermissionSaved: () => exports_saved,
+  ListInput: () => ListInput,
+  Info: () => Info,
+  ID: () => ID,
+  AddInput: () => AddInput
+});
+import { eq } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { PermissionSaved } from "@opencode-ai/schema/permission-saved";
+var ID = PermissionSaved.ID;
+var Info = PermissionSaved.Info;
+var ListInput = Schema.Struct({
+  projectID: exports_project.ID.pipe(Schema.optional)
+}).annotate({ identifier: "PermissionSaved.ListInput" });
+var AddInput = Schema.Struct({
+  projectID: exports_project.ID,
+  action: Schema.String,
+  resources: Schema.Array(Schema.String)
+}).annotate({ identifier: "PermissionSaved.AddInput" });
+
+class Service extends Context.Service()("@opencode/PermissionSaved") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  const list = Effect.fn("PermissionSaved.list")(function* (input) {
+    const rows = yield* db.select().from(PermissionTable).where(input?.projectID ? eq(PermissionTable.project_id, input.projectID) : undefined).all().pipe(Effect.orDie);
+    return rows.map((row) => ({
+      id: row.id,
+      projectID: row.project_id,
+      action: row.action,
+      resource: row.resource
+    }));
+  });
+  const add = Effect.fn("PermissionSaved.add")(function* (input) {
+    if (!input.resources.length)
+      return;
+    yield* db.insert(PermissionTable).values(input.resources.map((resource) => ({
+      id: ID.create(),
+      project_id: input.projectID,
+      action: input.action,
+      resource
+    }))).onConflictDoNothing().run().pipe(Effect.orDie);
+  });
+  const remove = Effect.fn("PermissionSaved.remove")(function* (id) {
+    yield* db.delete(PermissionTable).where(eq(PermissionTable.id, id)).run().pipe(Effect.orDie);
+  });
+  return Service.of({ list, add, remove });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { ID, Info, ListInput, AddInput, Service, node, exports_saved };

package/dist/chunks/permission-1wcz8fvj.js

@@ -0,0 +1,16 @@
+// src/github-copilot/openai-compatible-error.ts
+import { z } from "zod/v4";
+var openaiCompatibleErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
+  })
+});
+var defaultOpenAICompatibleErrorStructure = {
+  errorSchema: openaiCompatibleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+};
+
+export { openaiCompatibleErrorDataSchema, defaultOpenAICompatibleErrorStructure };

package/dist/chunks/permission-1xksxgzs.js

@@ -0,0 +1,24 @@
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/model-headers.ts
+var exports_model_headers = {};
+__export(exports_model_headers, {
+  make: () => make,
+  SessionModelHeaders: () => exports_model_headers
+});
+var make = (session, app) => ({
+  "x-session-affinity": session.id,
+  "X-Session-Id": session.id,
+  ...session.parentID ? { "x-parent-session-id": session.parentID } : {},
+  "User-Agent": exports_app.useragent(app),
+  "x-opencode-project": session.projectID,
+  "x-opencode-session": session.id,
+  "x-opencode-client": app.name
+});
+
+export { make, exports_model_headers };