@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-d0n9nbkk.js

@@ -0,0 +1,70 @@
+import {
+  exports_markdown
+} from "./permission-7wcmqxrc.js";
+import {
+  exports_skill
+} from "./permission-zr271bqv.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/config/plugin/skill-file.ts
+var exports_skill_file = {};
+__export(exports_skill_file, {
+  parse: () => parse,
+  SkillFile: () => exports_skill_file
+});
+import path from "path";
+import { Result, Schema, SchemaParser } from "effect";
+var Frontmatter = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  slash: Schema.Boolean.pipe(Schema.optional),
+  metadata: Schema.Unknown.pipe(Schema.optional)
+});
+var decodeFrontmatter = SchemaParser.decodeUnknownResult(Frontmatter);
+var metadataBoolean = (metadata, key) => {
+  if (metadata === undefined || metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return;
+  }
+  const value = Reflect.get(metadata, key);
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value !== "string")
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  return;
+};
+function parse(directory, filepath, content) {
+  const markdown = exports_markdown.parseOption(content);
+  if (!markdown)
+    return { _tag: "Skipped", reason: "markdown" };
+  const decoded = decodeFrontmatter(markdown.data);
+  if (Result.isFailure(decoded))
+    return { _tag: "Skipped", reason: "frontmatter", issue: decoded.failure };
+  const frontmatter = decoded.success;
+  const id = path.dirname(filepath) === directory ? path.basename(filepath, ".md") : path.basename(path.dirname(filepath));
+  const slash = metadataBoolean(frontmatter.metadata, "opencode/slash") ?? frontmatter.slash;
+  const autoinvoke = metadataBoolean(frontmatter.metadata, "opencode/autoinvoke");
+  return {
+    _tag: "Parsed",
+    skill: {
+      id: exports_skill.ID.make(id),
+      name: exports_skill.Name.make(frontmatter.name ?? id),
+      ...frontmatter.description === undefined ? {} : { description: frontmatter.description },
+      ...slash === undefined ? {} : { slash },
+      ...autoinvoke === undefined ? {} : { autoinvoke },
+      location: AbsolutePath.make(filepath),
+      content: markdown.content
+    }
+  };
+}
+
+export { parse, exports_skill_file };

package/dist/chunks/permission-d4a2h60z.js

@@ -0,0 +1,222 @@
+import {
+  exports_mcp
+} from "./permission-qnjh8g89.js";
+import {
+  exports_select
+} from "./permission-04kwjb53.js";
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  exports_state
+} from "./permission-wt193r4g.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/command.ts
+var exports_command = {};
+__export(exports_command, {
+  node: () => node,
+  layer: () => layer,
+  configured: () => configured,
+  Service: () => Service,
+  NotFoundError: () => NotFoundError,
+  Info: () => Info,
+  Event: () => Event,
+  EvaluationError: () => EvaluationError,
+  Command: () => exports_command
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Command } from "@opencode-ai/schema/command";
+import { AppProcess } from "@opencode-ai/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { Global } from "@opencode-ai/util/global";
+import { Event } from "@opencode-ai/schema/command";
+var Info = Command.Info;
+
+class NotFoundError extends Schema.TaggedErrorClass()("Command.NotFoundError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class EvaluationError extends Schema.TaggedErrorClass()("Command.EvaluationError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Command") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const mcp = yield* exports_mcp.Service;
+  const bus = yield* exports_bus.Service;
+  const processes = yield* AppProcess.Service;
+  const config = yield* exports_config.Service;
+  const location = yield* exports_location.Service;
+  const global = yield* Global.Service;
+  const state = exports_state.create({
+    name: "command",
+    initial: () => ({ commands: new Map }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.commands.values()),
+      get: (name) => draft.commands.get(name),
+      update: (name, update) => {
+        const current = draft.commands.get(name) ?? { name, template: "" };
+        if (!draft.commands.has(name))
+          draft.commands.set(name, current);
+        update(current);
+        current.name = name;
+      },
+      remove: (name) => {
+        draft.commands.delete(name);
+      }
+    }),
+    finalize: () => bus.publish(Command.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const staticCommand = (name) => state.get().commands.get(name);
+  const mcpCommands = Effect.fnUntraced(function* () {
+    return (yield* mcp.prompts()).map((prompt) => Info.make({
+      name: mcpCommandName(prompt.server, prompt.name),
+      template: "",
+      description: prompt.description
+    }));
+  });
+  return Service.of({
+    reload: state.reload,
+    transform: state.transform,
+    get: Effect.fn("Command.get")(function* (name) {
+      const command = staticCommand(name);
+      if (command)
+        return command;
+      return (yield* mcpCommands()).find((command2) => command2.name === name);
+    }),
+    list: Effect.fn("Command.list")(function* () {
+      const commands = Array.from(state.get().commands.values());
+      const names = new Set(commands.map((command) => command.name));
+      return [...commands, ...(yield* mcpCommands()).filter((command) => !names.has(command.name))];
+    }),
+    evaluate: Effect.fn("Command.evaluate")(function* (input) {
+      const command = staticCommand(input.name);
+      if (command)
+        return yield* evaluateTemplate(input.name, command.template, input.arguments ?? "", {
+          config,
+          location,
+          processes,
+          shell: options,
+          bin: global.bin
+        });
+      const prompt = (yield* mcp.prompts()).find((prompt2) => mcpCommandName(prompt2.server, prompt2.name) === input.name);
+      if (!prompt)
+        return yield* new NotFoundError({ command: input.name, message: `Command not found: ${input.name}` });
+      const result = yield* mcp.prompt({
+        server: prompt.server,
+        name: prompt.name,
+        args: Object.fromEntries((prompt.arguments ?? []).map((argument, index) => [
+          argument.name,
+          parseArguments(input.arguments ?? "")[index] ?? ""
+        ]))
+      }).pipe(Effect.catchTag("MCP.NotFoundError", () => Effect.fail(new EvaluationError({
+        command: input.name,
+        message: `MCP server could not be found while evaluating prompt: ${prompt.server}`
+      }))));
+      if (!result)
+        return yield* new EvaluationError({
+          command: input.name,
+          message: `MCP prompt could not be evaluated: ${prompt.server}:${prompt.name}`
+        });
+      return {
+        text: result.messages.map((message) => promptMessageText(message.content)).join(`
+`).trim()
+      };
+    })
+  });
+}));
+function evaluateTemplate(command, template, input, services) {
+  return Effect.gen(function* () {
+    const expanded = evaluateArguments(template, input);
+    return { text: yield* evaluateShell(command, expanded, services) };
+  });
+}
+function evaluateArguments(template, input) {
+  const args = parseArguments(input);
+  const placeholders = template.match(placeholderRegex) ?? [];
+  const last = Math.max(0, ...placeholders.map((item) => Number(item.slice(1))));
+  const expanded = template.replaceAll(placeholderRegex, (_, index) => {
+    const position = Number(index);
+    const argIndex = position - 1;
+    if (argIndex >= args.length)
+      return "";
+    if (position === last)
+      return args.slice(argIndex).join(" ");
+    return args[argIndex];
+  });
+  const withArguments = expanded.replaceAll("$ARGUMENTS", input);
+  if (placeholders.length === 0 && !template.includes("$ARGUMENTS") && input.trim())
+    return `${withArguments}
+
+${input}`.trim();
+  return withArguments.trim();
+}
+var evaluateShell = Effect.fnUntraced(function* (command, text, services) {
+  const matches = Array.from(text.matchAll(shellRegex));
+  if (matches.length === 0)
+    return text;
+  const shell = exports_select.preferred(exports_config.latest(yield* services.config.entries(), "shell"), services.shell, services.bin);
+  const outputs = yield* Effect.forEach(matches, (match) => {
+    const source = match[1] ?? "";
+    return services.processes.run(ChildProcess.make(shell, exports_select.args(shell, source), {
+      cwd: services.location.directory,
+      stdin: "ignore"
+    }), {
+      combineOutput: true
+    }).pipe(Effect.map((result) => (result.output ?? Buffer.concat([result.stdout, result.stderr])).toString("utf8")), Effect.mapError((error) => new EvaluationError({
+      command,
+      message: `Shell interpolation failed for ${JSON.stringify(source)}: ${error.message}`
+    })));
+  }, { concurrency: 2 });
+  const iterator = outputs[Symbol.iterator]();
+  return text.replace(shellRegex, () => iterator.next().value ?? "");
+});
+function parseArguments(input) {
+  return (input.match(argsRegex) ?? []).map((arg) => arg.replace(quoteTrimRegex, ""));
+}
+function promptMessageText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!content || typeof content !== "object")
+    return "";
+  if (!("type" in content) || content.type !== "text")
+    return "";
+  if (!("text" in content) || typeof content.text !== "string")
+    return "";
+  return content.text;
+}
+function mcpCommandName(server, prompt) {
+  return `${sanitize(server)}:${sanitize(prompt)}`;
+}
+function sanitize(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+var argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
+var placeholderRegex = /\$(\d+)/g;
+var quoteTrimRegex = /^["']|["']$/g;
+var shellRegex = /!`([^`]+)`/g;
+function configured(options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [exports_mcp.node, exports_bus.node, AppProcess.node, exports_config.node, exports_location.node, Global.node]
+  });
+}
+var node = configured();
+
+export { Info, NotFoundError, EvaluationError, Service, layer, configured, node, exports_command, Event };

package/dist/chunks/permission-d5t1sv80.js

@@ -0,0 +1,103 @@
+import {
+  CredentialTable
+} from "./permission-mf0hyk7z.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/credential.ts
+var exports_credential = {};
+__export(exports_credential, {
+  node: () => node,
+  Value: () => Value,
+  Service: () => Service,
+  OAuth: () => OAuth,
+  Key: () => Key,
+  Info: () => Info,
+  ID: () => ID,
+  Credential: () => exports_credential
+});
+import { asc, eq } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Credential } from "@opencode-ai/schema/credential";
+import { Integration } from "@opencode-ai/schema/integration";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var ID = Credential.ID;
+var OAuth = Credential.OAuth;
+var Key = Credential.Key;
+var Value = Credential.Value;
+
+class Info extends Schema.Class("Credential.Info")({
+  id: ID,
+  integrationID: Integration.ID,
+  label: Schema.String,
+  value: Value
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Credential") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  const decode = Schema.decodeUnknownSync(Value);
+  const stored = (row) => {
+    if (!row.integration_id)
+      return;
+    return new Info({
+      id: row.id,
+      integrationID: row.integration_id,
+      label: row.label,
+      value: decode(row.value)
+    });
+  };
+  return Service.of({
+    all: Effect.fn("Credential.all")(function* () {
+      return (yield* db.select().from(CredentialTable).orderBy(asc(CredentialTable.time_created)).all().pipe(Effect.orDie)).flatMap((row) => {
+        const credential = stored(row);
+        return credential ? [credential] : [];
+      });
+    }),
+    list: Effect.fn("Credential.list")(function* (integrationID) {
+      return (yield* db.select().from(CredentialTable).where(eq(CredentialTable.integration_id, integrationID)).orderBy(asc(CredentialTable.time_created)).all().pipe(Effect.orDie)).flatMap((row) => {
+        const credential = stored(row);
+        return credential ? [credential] : [];
+      });
+    }),
+    get: Effect.fn("Credential.get")(function* (id) {
+      const row = yield* db.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
+      return row ? stored(row) : undefined;
+    }),
+    create: Effect.fn("Credential.create")(function* (input) {
+      const credential = new Info({
+        id: ID.create(),
+        integrationID: input.integrationID,
+        label: input.label ?? "default",
+        value: input.value
+      });
+      yield* db.transaction((tx) => Effect.gen(function* () {
+        yield* tx.delete(CredentialTable).where(eq(CredentialTable.integration_id, credential.integrationID)).run();
+        yield* tx.insert(CredentialTable).values({
+          id: credential.id,
+          integration_id: credential.integrationID,
+          label: credential.label,
+          value: credential.value
+        }).run();
+      })).pipe(Effect.orDie);
+      return credential;
+    }),
+    update: Effect.fn("Credential.update")(function* (id, updates) {
+      if (!updates.label && !updates.value)
+        return;
+      yield* db.update(CredentialTable).set({ label: updates.label, value: updates.value }).where(eq(CredentialTable.id, id)).run().pipe(Effect.orDie);
+    }),
+    remove: Effect.fn("Credential.remove")(function* (id) {
+      yield* db.delete(CredentialTable).where(eq(CredentialTable.id, id)).run().pipe(Effect.orDie);
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { ID, OAuth, Key, Value, Info, Service, node, exports_credential };

package/dist/chunks/permission-d6s8p2vk.js

@@ -0,0 +1,157 @@
+// src/tool/runtime.ts
+import { Tool } from "@opencode-ai/schema/tool";
+import { Effect, Schema } from "effect";
+var definition = (tool) => ({
+  name: effectiveName(tool),
+  description: tool.description,
+  inputSchema: inputJsonSchema(tool.input),
+  ...tool.output === undefined ? {} : { outputSchema: outputJsonSchema(tool.output) }
+});
+var execute = (tool, input, context) => Effect.gen(function* () {
+  const decoded = yield* decodeInput(tool.input, input);
+  const result = yield* tool.execute(decoded, context);
+  if (tool.output === undefined) {
+    if ("output" in result)
+      return yield* Effect.die("Tool result declared output without an output schema");
+    return {
+      output: undefined,
+      content: normalizeContent(result.content),
+      ...result.metadata === undefined ? {} : { metadata: result.metadata }
+    };
+  }
+  if (!("output" in result))
+    return yield* new Tool.Error({ message: "Tool did not return its declared output" });
+  const output = yield* encodeOutput(tool.output, result.output);
+  return {
+    output,
+    content: normalizeContent(result.content, output),
+    ...result.metadata === undefined ? {} : { metadata: result.metadata }
+  };
+});
+var decodeInput = (schema, value) => {
+  if (Schema.isSchema(schema))
+    return Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Invalid tool input: ${error.message}` })));
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value, "Invalid tool input");
+  return Effect.succeed(value);
+};
+var encodeOutput = (schema, value) => {
+  if (Schema.isSchema(schema))
+    return Schema.encodeEffect(schema)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned an invalid value for its output schema: ${error.message}` })));
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value, "Tool returned an invalid value for its output schema");
+  return Schema.decodeUnknownEffect(Schema.Json)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned a non-JSON value for its output schema: ${error.message}` })));
+};
+var isStandardSchema = (schema) => typeof schema === "object" && schema !== null && ("~standard" in schema);
+var validateStandard = (schema, value, prefix) => Effect.gen(function* () {
+  const pending = yield* Effect.try({
+    try: () => schema["~standard"].validate(value),
+    catch: (error) => standardFailure(prefix, error)
+  });
+  const result = pending instanceof Promise ? yield* Effect.tryPromise({ try: () => pending, catch: (error) => standardFailure(prefix, error) }) : pending;
+  if (result.issues)
+    return yield* new Tool.Error({
+      message: `${prefix}: ${result.issues.map((issue) => issue.message).join(", ")}`
+    });
+  return result.value;
+});
+var standardFailure = (prefix, error) => new Tool.Error({ message: `${prefix}: ${error instanceof Error ? error.message : String(error)}` });
+var inputJsonSchema = (schema) => {
+  if (schema === undefined || schema === null)
+    return {};
+  if (isStandardSchema(schema))
+    return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var outputJsonSchema = (schema) => {
+  if (isStandardSchema(schema))
+    return schema["~standard"].jsonSchema.output({ target: "draft-2020-12" });
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var toJsonSchema = (schema) => {
+  const document = Schema.toJsonSchemaDocument(schema);
+  const normalized = flattenAllOf(Object.keys(document.definitions).length === 0 ? document.schema : { ...document.schema, $defs: document.definitions });
+  return dropDefinitionsIfResolved(inlineLocalReferences(normalized));
+};
+var flattenAllOf = (value) => {
+  if (Array.isArray(value))
+    return value.map(flattenAllOf);
+  if (typeof value !== "object" || value === null)
+    return value;
+  const schema = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, flattenAllOf(item)]));
+  if (!Array.isArray(schema.allOf) || !schema.allOf.every(isRecord) || !canFlattenAllOf(schema.allOf, schema))
+    return schema;
+  const { allOf, ...rest } = schema;
+  return flattenAllOf({ ...Object.assign({}, ...allOf), ...rest });
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var canFlattenAllOf = (allOf, parent) => {
+  const keys = new Set(Object.keys(parent).filter((key) => key !== "allOf"));
+  return allOf.every((item) => Object.keys(item).every((key) => {
+    if (keys.has(key))
+      return false;
+    keys.add(key);
+    return true;
+  }));
+};
+var inlineLocalReferences = (value, definitions, seen = new Set) => {
+  if (Array.isArray(value))
+    return value.map((item) => inlineLocalReferences(item, definitions, seen));
+  if (!isRecord(value))
+    return value;
+  const localDefinitions = definitions ?? (isRecord(value.$defs) ? value.$defs : undefined);
+  if (typeof value.$ref === "string" && localDefinitions) {
+    const segment = value.$ref.match(/^#\/\$defs\/([^/]+)$/)?.[1];
+    const name = segment?.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (name && !seen.has(name)) {
+      const target = localDefinitions[name];
+      if (target) {
+        const { $ref: _, ...rest } = value;
+        const resolvedTarget = inlineLocalReferences(target, localDefinitions, new Set(seen).add(name));
+        const resolvedSiblings = inlineLocalReferences(rest, localDefinitions, seen);
+        if (!isRecord(resolvedTarget) || !isRecord(resolvedSiblings))
+          return resolvedTarget;
+        if (canMergeRecords(resolvedTarget, resolvedSiblings))
+          return { ...resolvedTarget, ...resolvedSiblings };
+        return { allOf: [resolvedTarget, resolvedSiblings] };
+      }
+    }
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, inlineLocalReferences(item, localDefinitions, seen)]));
+};
+var canMergeRecords = (left, right) => Object.keys(left).every((key) => !(key in right));
+var dropDefinitionsIfResolved = (value) => {
+  if (!isRecord(value) || hasLocalReference(value))
+    return value;
+  const { $defs: _, ...rest } = value;
+  return rest;
+};
+var hasLocalReference = (value) => {
+  if (Array.isArray(value))
+    return value.some(hasLocalReference);
+  if (!isRecord(value))
+    return false;
+  if (typeof value.$ref === "string" && value.$ref.startsWith("#/$defs/"))
+    return true;
+  return Object.values(value).some(hasLocalReference);
+};
+var normalizeContent = (value, output) => {
+  if (typeof value === "string")
+    return [{ type: "text", text: value }];
+  if (value !== undefined && value.length > 0)
+    return [...value];
+  return [{ type: "text", text: stringify(output) }];
+};
+var stringify = (value) => {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var normalizedName = (tool) => tool.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+var effectiveName = (tool) => tool.options?.namespace === undefined ? normalizedName(tool) : `${tool.options.namespace.replaceAll(".", "_")}_${normalizedName(tool)}`;
+
+export { definition, execute, normalizeContent };