argsbarg 6.1.6 → 6.1.8

package/src/config/file.test.ts

@@ -6,7 +6,7 @@ import { describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import type { CliProgram } from "~/core/types.ts";
+import type { CliProgram } from "../core/types.ts";
 import { CONFIG_BINDINGS_KEY } from "./bindings.ts";
 import { bootstrapAppConfig } from "./bootstrap.ts";
 import {

package/src/config/file.ts

@@ -4,9 +4,9 @@ JSON app config file path helpers and strict read/write.
 
 import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { CliProgram } from "~/core/types.ts";
-import { sanitizeToolSegment } from "~/mcp/tools.ts";
-import { appConfigLibHome, displayHomePath } from "~/paths/host.ts";
+import type { CliProgram } from "../core/types.ts";
+import { sanitizeToolSegment } from "../mcp/tools.ts";
+import { appConfigLibHome, displayHomePath } from "../paths/host.ts";
 import { isFrameworkConfigKey, validateBindingsShape } from "./bindings.ts";
 import { effectiveJsonSchema } from "./schema.ts";
 import { validateConfigDocument, validateConfigDocumentPartial } from "./validate.ts";

package/src/config/manifest.ts

@@ -2,7 +2,7 @@
 MCP bundle / plugin manifest builders for program.appConfig env-mapped entries.
 */
 
-import type { CliAppConfigEntry, CliProgram } from "~/core/types.ts";
+import type { CliAppConfigEntry, CliProgram } from "../core/types.ts";
 import {
   configEntryRequired,
   configEntrySensitive,

package/src/config/resolve.test.ts

@@ -3,7 +3,7 @@ Tests for config/resolve module behavior.
 */
 
 import { describe, expect, test } from "bun:test";
-import type { CliProgram } from "~/core/types.ts";
+import type { CliProgram } from "../core/types.ts";
 import { captureMappedHostEnv, exportConfigToEnv, resolveAppConfig } from "./resolve.ts";
 
 const program: CliProgram = {

package/src/config/resolve.ts

@@ -2,7 +2,7 @@
 Resolve program.appConfig values: defaults, file, env override, export to process.env.
 */
 
-import type { CliAppConfigEntry, CliAppConfigResolveContext, CliProgram } from "~/core/types.ts";
+import type { CliAppConfigEntry, CliAppConfigResolveContext, CliProgram } from "../core/types.ts";
 import { configEntryRequired, jsonSchemaRequiredKeys } from "./entry.ts";
 import type { AppConfigFileData } from "./file.ts";
 import { displayAppConfigPath } from "./file.ts";

package/src/config/schema.ts

@@ -2,7 +2,7 @@
 Effective JSON Schema for program.appConfig (block schema or all-string synthesis).
 */
 
-import type { CliAppConfigEntry, CliProgram } from "~/core/types.ts";
+import type { CliAppConfigEntry, CliProgram } from "../core/types.ts";
 import { configEntryRequired, jsonSchemaRequiredKeys } from "./entry.ts";
 
 /** Synthesize a draft-07 object schema with string properties from metadata entries. */

package/src/config/validate.test.ts

@@ -3,7 +3,7 @@ Tests for config/validate module behavior.
 */
 
 import { describe, expect, test } from "bun:test";
-import { parseConfigSetValue, validateConfigDocument } from "./validate.ts";
+import { parseConfigSetValue, resolveSchemaDraft, validateConfigDocument } from "./validate.ts";
 
 const rootSchema = {
   type: "object",
@@ -98,4 +98,48 @@ describe("config/validate", () => {
     expect(() => parseConfigSetValue("a,b", schema, rootSchema, false)).toThrow(/--json/);
     expect(parseConfigSetValue('[{"ttl":1}]', schema, rootSchema, false)).toEqual([{ ttl: 1 }]);
   });
+
+  test("resolveSchemaDraft maps $schema URIs", () => {
+    expect(resolveSchemaDraft({ $schema: "http://json-schema.org/draft-07/schema#" })).toBe("7");
+    expect(resolveSchemaDraft({ $schema: "https://json-schema.org/draft/2020-12/schema" })).toBe("2020-12");
+    expect(resolveSchemaDraft({ $schema: "https://json-schema.org/draft/2019-09/schema" })).toBe("2019-09");
+    expect(resolveSchemaDraft({})).toBe("7");
+  });
+
+  test("validates draft 2020-12 schemas when $schema is set", () => {
+    const schema = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      additionalProperties: false,
+      required: ["name"],
+      properties: {
+        name: { type: "string", minLength: 1 },
+      },
+    };
+    expect(validateConfigDocument({ name: "ok" }, schema).valid).toBe(true);
+    expect(validateConfigDocument({ name: "" }, schema).valid).toBe(false);
+    expect(validateConfigDocument({}, schema).valid).toBe(false);
+  });
+
+  test("validates draft 2020-12 $defs refs", () => {
+    const schema = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      additionalProperties: false,
+      required: ["item"],
+      properties: {
+        item: { $ref: "#/$defs/Item" },
+      },
+      $defs: {
+        Item: {
+          type: "object",
+          additionalProperties: false,
+          required: ["id"],
+          properties: { id: { type: "string" } },
+        },
+      },
+    };
+    expect(validateConfigDocument({ item: { id: "a" } }, schema).valid).toBe(true);
+    expect(validateConfigDocument({ item: { id: 1 } }, schema).valid).toBe(false);
+  });
 });

package/src/config/validate.ts

@@ -1,9 +1,10 @@
 /*
-Draft-07 JSON Schema subset validator for program.appConfig files.
-Aligned with common ts-json-schema-generator output (local $ref, objects, scalars).
+JSON Schema validation for program.appConfig and leaf inputSchema (@cfworker/json-schema).
+CLI value coercion for configure set remains here (comma-separated arrays, booleans, etc.).
 */
 
-import { parseCommaList, parseDate, parseDateTime } from "~/core/formats.ts";
+import { format as jsonSchemaFormats, type Schema, type SchemaDraft, Validator } from "@cfworker/json-schema";
+import { parseCommaList, parseDate, parseDateTime, validateCommaList } from "../core/formats.ts";
 import { isFrameworkConfigKey } from "./bindings.ts";
 
 type JsonSchema = Record<string, unknown>;
@@ -19,248 +20,183 @@ export interface ValidateResult {
   errors: string[];
 }
 
-/** Validate `data` against a JSON Schema root. Returns human-readable error messages. */
-export function validateConfigDocument(data: unknown, rootSchema: JsonSchema): ValidateResult {
-  const errors: string[] = [];
-  validateValue(data, rootSchema, rootSchema, "$", errors, false);
-  return { valid: errors.length === 0, errors };
-}
-
-/** Validate present keys only — skips root `required` checks (partial writes / bootstrap). */
-export function validateConfigDocumentPartial(data: unknown, rootSchema: JsonSchema): ValidateResult {
-  const errors: string[] = [];
-  validateValue(data, rootSchema, rootSchema, "$", errors, true);
-  return { valid: errors.length === 0, errors };
-}
-
-function validateValue(
-  value: unknown,
-  schema: JsonSchema,
-  root: JsonSchema,
-  path: string,
-  errors: string[],
-  partial: boolean,
-): void {
-  const resolved = resolveSchema(schema, root);
-  if (!resolved) {
-    return;
-  }
-
-  if ("const" in resolved) {
-    if (value !== resolved.const) {
-      errors.push(`${path}: must be ${JSON.stringify(resolved.const)}`);
+if (!jsonSchemaFormats["comma-list"]) {
+  jsonSchemaFormats["comma-list"] = (value: string) => {
+    try {
+      validateCommaList(value);
+      return true;
+    } catch {
+      return false;
     }
-    return;
-  }
+  };
+}
 
-  if (Array.isArray(resolved.enum)) {
-    if (!resolved.enum.some((item) => item === value)) {
-      errors.push(`${path}: must be one of ${JSON.stringify(resolved.enum)}`);
-    }
-    return;
+function dataForSchemaValidation(data: unknown): unknown {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    return data;
   }
-
-  const anyOf = resolved.anyOf ?? resolved.oneOf;
-  if (Array.isArray(anyOf)) {
-    const branchErrors: string[][] = [];
-    for (const branch of anyOf) {
-      if (typeof branch !== "object" || branch === null || Array.isArray(branch)) {
-        continue;
-      }
-      const branchErrs: string[] = [];
-      validateValue(value, branch as JsonSchema, root, path, branchErrs, partial);
-      if (branchErrs.length === 0) {
-        return;
-      }
-      branchErrors.push(branchErrs);
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (isFrameworkConfigKey(key)) {
+      continue;
     }
-    errors.push(`${path}: must match one of the allowed types`);
-    if (branchErrors.length === 1 && branchErrors[0]?.[0]) {
-      errors.push(branchErrors[0][0]);
-    }
-    return;
-  }
-
-  const types = normalizeTypes(resolved.type);
-  if (types.length > 0 && !matchesAnyType(value, types)) {
-    errors.push(`${path}: must be ${types.join(" or ")}`);
-    return;
+    out[key] = value;
   }
+  return out;
+}
 
-  if (types.includes("string") || (types.length === 0 && typeof value === "string")) {
-    validateString(value, resolved, path, errors);
+function schemaWithoutRequired(schema: unknown): JsonSchema {
+  if (typeof schema !== "object" || schema === null) {
+    return schema as JsonSchema;
   }
-  if (types.includes("number") || types.includes("integer")) {
-    validateNumber(value, resolved, path, errors, types.includes("integer"));
+  if (Array.isArray(schema)) {
+    return schema.map(schemaWithoutRequired) as unknown as JsonSchema;
   }
-  if (types.includes("boolean")) {
-    if (typeof value !== "boolean") {
-      errors.push(`${path}: must be boolean`);
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "required") {
+      continue;
     }
+    out[key] = schemaWithoutRequired(value);
   }
-  if (types.includes("null") && value !== null) {
-    errors.push(`${path}: must be null`);
-  }
-  if (types.includes("object") || (types.length === 0 && isPlainObject(value))) {
-    validateObject(value, resolved, root, path, errors, partial);
-  }
-  if (types.includes("array") || (types.length === 0 && Array.isArray(value))) {
-    validateArray(value, resolved, root, path, errors, partial);
-  }
+  return out as JsonSchema;
 }
 
-function resolveSchema(schema: JsonSchema, root: JsonSchema): JsonSchema | undefined {
-  const ref = schema.$ref;
-  if (typeof ref === "string" && ref.startsWith("#/definitions/")) {
-    const name = decodeURIComponent(ref.slice("#/definitions/".length));
-    const definitions = root.definitions;
-    if (typeof definitions !== "object" || definitions === null || Array.isArray(definitions)) {
-      return schema;
-    }
-    const target = (definitions as Record<string, unknown>)[name];
-    if (typeof target === "object" && target !== null && !Array.isArray(target)) {
-      return target as JsonSchema;
-    }
+function formatInstancePath(instanceLocation: string): string {
+  if (instanceLocation.length === 0 || instanceLocation === "#") {
+    return "$";
   }
-  return schema;
-}
-
-function normalizeTypes(type: unknown): string[] {
-  if (typeof type === "string") {
-    return [type];
+  if (instanceLocation.startsWith("#/")) {
+    return instanceLocation.slice(2).replace(/\//g, ".");
   }
-  if (Array.isArray(type)) {
-    return type.filter((t): t is string => typeof t === "string");
-  }
-  return [];
+  return instanceLocation;
 }
 
-function matchesAnyType(value: unknown, types: string[]): boolean {
-  for (const t of types) {
-    if (t === "null" && value === null) return true;
-    if (t === "array" && Array.isArray(value)) return true;
-    if (t === "object" && isPlainObject(value)) return true;
-    if (t === "integer" && typeof value === "number" && Number.isInteger(value)) return true;
-    if (t === "number" && typeof value === "number") return true;
-    if (t === "boolean" && typeof value === "boolean") return true;
-    if (t === "string" && typeof value === "string") return true;
-  }
-  return types.length === 0;
+function formatValidationErrors(errors: { instanceLocation: string; error: string }[]): string[] {
+  return errors.map(({ instanceLocation, error }) => {
+    const path = formatInstancePath(instanceLocation);
+    return `${path}: ${error}`;
+  });
 }
 
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function decodeJsonPointerSegment(segment: string): string {
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
 }
 
-function validateString(value: unknown, schema: JsonSchema, path: string, errors: string[]): void {
-  if (typeof value !== "string") {
-    errors.push(`${path}: must be string`);
-    return;
+/** Map a schema `$schema` URI to the @cfworker/json-schema draft (defaults to Draft-07). */
+export function resolveSchemaDraft(schema: JsonSchema): SchemaDraft {
+  const $schema = schema.$schema;
+  if (typeof $schema !== "string") {
+    return "7";
   }
-  if (typeof schema.minLength === "number" && value.length < schema.minLength) {
-    errors.push(`${path}: string shorter than minLength ${schema.minLength}`);
+  const normalized = $schema.toLowerCase();
+  if (normalized.includes("2020-12")) {
+    return "2020-12";
   }
-  if (typeof schema.maxLength === "number" && value.length > schema.maxLength) {
-    errors.push(`${path}: string longer than maxLength ${schema.maxLength}`);
+  if (normalized.includes("2019-09")) {
+    return "2019-09";
   }
-  if (typeof schema.pattern === "string") {
-    try {
-      if (!new RegExp(schema.pattern).test(value)) {
-        errors.push(`${path}: does not match pattern`);
-      }
-    } catch {
-      /* invalid pattern in schema — skip */
+  if (normalized.includes("draft-04") || normalized.includes("draft/4")) {
+    return "4";
+  }
+  if (normalized.includes("draft-07") || normalized.includes("draft/7")) {
+    return "7";
+  }
+  return "7";
+}
+
+function resolveJsonPointer(root: JsonSchema, ref: string): unknown {
+  if (!ref.startsWith("#/")) {
+    return undefined;
+  }
+  const segments = ref
+    .slice(2)
+    .split("/")
+    .filter((segment) => segment.length > 0)
+    .map(decodeJsonPointerSegment);
+  let current: unknown = root;
+  for (const segment of segments) {
+    if (typeof current !== "object" || current === null || Array.isArray(current)) {
+      return undefined;
     }
+    current = (current as Record<string, unknown>)[segment];
   }
+  return current;
 }
 
-function validateNumber(value: unknown, schema: JsonSchema, path: string, errors: string[], integer: boolean): void {
-  if (typeof value !== "number" || Number.isNaN(value)) {
-    errors.push(`${path}: must be number`);
+function attachRootCompanionSchemas(validator: Validator, root: JsonSchema, active: JsonSchema): void {
+  if (active === root) {
     return;
   }
-  if (integer && !Number.isInteger(value)) {
-    errors.push(`${path}: must be integer`);
+  const companion: Schema = {};
+  if (typeof root.definitions === "object" && root.definitions !== null && !Array.isArray(root.definitions)) {
+    companion.definitions = root.definitions;
   }
-  if (typeof schema.minimum === "number" && value < schema.minimum) {
-    errors.push(`${path}: below minimum ${schema.minimum}`);
+  if (typeof root.$defs === "object" && root.$defs !== null && !Array.isArray(root.$defs)) {
+    companion.$defs = root.$defs;
   }
-  if (typeof schema.maximum === "number" && value > schema.maximum) {
-    errors.push(`${path}: above maximum ${schema.maximum}`);
+  if (Object.keys(companion).length > 0) {
+    validator.addSchema(companion);
   }
 }
 
-function validateObject(
-  value: unknown,
+function validatorForSchema(schema: JsonSchema, root: JsonSchema, partial: boolean): Validator {
+  const active = partial ? schemaWithoutRequired(schema) : schema;
+  const validator = new Validator(active as Schema, resolveSchemaDraft(root), false);
+  attachRootCompanionSchemas(validator, root, active);
+  return validator;
+}
+
+function validateInstance(
+  data: unknown,
   schema: JsonSchema,
   root: JsonSchema,
-  path: string,
-  errors: string[],
   partial: boolean,
-): void {
-  if (!isPlainObject(value)) {
-    errors.push(`${path}: must be object`);
-    return;
-  }
-  const properties = schema.properties;
-  const propMap =
-    typeof properties === "object" && properties !== null && !Array.isArray(properties)
-      ? (properties as Record<string, JsonSchema>)
-      : undefined;
+  stripFrameworkKeys: boolean,
+): ValidateResult {
+  const validator = validatorForSchema(schema, root, partial);
+  const payload = stripFrameworkKeys ? dataForSchemaValidation(data) : data;
+  const result = validator.validate(payload);
+  if (result.valid) {
+    return { valid: true, errors: [] };
+  }
+  return { valid: false, errors: formatValidationErrors(result.errors) };
+}
 
-  if (propMap) {
-    for (const [key, propSchema] of Object.entries(propMap)) {
-      if (key in value) {
-        validateValue(value[key], propSchema, root, `${path}.${key}`, errors, partial);
-      }
-    }
-  }
+function validateAgainstSchema(data: unknown, rootSchema: JsonSchema, partial: boolean): ValidateResult {
+  return validateInstance(data, rootSchema, rootSchema, partial, true);
+}
 
-  if (!partial) {
-    const required = schema.required;
-    if (Array.isArray(required)) {
-      for (const key of required) {
-        if (typeof key === "string" && !(key in value)) {
-          errors.push(`${path}: missing required property '${key}'`);
-        }
-      }
-    }
-  }
+/** Validate `data` against a JSON Schema root. Returns human-readable error messages. */
+export function validateConfigDocument(data: unknown, rootSchema: JsonSchema): ValidateResult {
+  return validateAgainstSchema(data, rootSchema, false);
+}
 
-  if (schema.additionalProperties === false && propMap) {
-    for (const key of Object.keys(value)) {
-      if (isFrameworkConfigKey(key)) continue;
-      if (!(key in propMap)) {
-        errors.push(`${path}: unknown property '${key}'`);
-      }
-    }
-  }
+/** Validate present keys only — skips `required` checks (partial writes / bootstrap). */
+export function validateConfigDocumentPartial(data: unknown, rootSchema: JsonSchema): ValidateResult {
+  return validateAgainstSchema(data, rootSchema, true);
 }
 
-function validateArray(
-  value: unknown,
-  schema: JsonSchema,
-  root: JsonSchema,
-  path: string,
-  errors: string[],
-  partial: boolean,
-): void {
-  if (!Array.isArray(value)) {
-    errors.push(`${path}: must be array`);
-    return;
+function resolveSchema(schema: JsonSchema, root: JsonSchema): JsonSchema | undefined {
+  const ref = schema.$ref;
+  if (typeof ref !== "string" || !ref.startsWith("#/")) {
+    return schema;
   }
-  if (typeof schema.minItems === "number" && value.length < schema.minItems) {
-    errors.push(`${path}: fewer than minItems ${schema.minItems}`);
+  const target = resolveJsonPointer(root, ref);
+  if (typeof target === "object" && target !== null && !Array.isArray(target)) {
+    return target as JsonSchema;
   }
-  if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
-    errors.push(`${path}: more than maxItems ${schema.maxItems}`);
+  return schema;
+}
+
+function normalizeTypes(type: unknown): string[] {
+  if (typeof type === "string") {
+    return [type];
   }
-  const items = schema.items;
-  if (typeof items === "object" && items !== null && !Array.isArray(items)) {
-    for (let i = 0; i < value.length; i++) {
-      validateValue(value[i], items as JsonSchema, root, `${path}[${i}]`, errors, partial);
-    }
+  if (Array.isArray(type)) {
+    return type.filter((t): t is string => typeof t === "string");
   }
+  return [];
 }
 
 export function validateParsedConfigValue(
@@ -271,10 +207,9 @@ export function validateParsedConfigValue(
   if (!propertySchema) {
     return parsed;
   }
-  const errors: string[] = [];
-  validateValue(parsed, propertySchema, rootSchema, "$", errors, false);
-  if (errors.length > 0) {
-    throw new Error(errors[0] ?? "Invalid config value");
+  const result = validateInstance(parsed, propertySchema, rootSchema, false, false);
+  if (!result.valid) {
+    throw new Error(result.errors[0] ?? "Invalid config value");
   }
   return parsed;
 }

package/src/configure/artifacts/binary-placement.test.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { chmodSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { CliProgram } from "~/core/types.ts";
+import type { CliProgram } from "../../core/types.ts";
 import { isAppInstalled, isExternallyManagedBinary, resolvePathCommand } from "./binary-placement.ts";
 
 const program: CliProgram = {

package/src/configure/artifacts/binary-placement.ts

@@ -1,6 +1,6 @@
 import { accessSync, constants, realpathSync } from "node:fs";
 import { delimiter, join } from "node:path";
-import type { CliProgram } from "~/core/types.ts";
+import type { CliProgram } from "../../core/types.ts";
 
 /** Resolves a command name on PATH to its real path, if present. */
 export function resolvePathCommand(key: string): string | undefined {

package/src/configure/artifacts/gh-release-update.ts

@@ -1,7 +1,7 @@
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import type { CliUpdateGetLatest } from "~/core/types.ts";
+import type { CliUpdateGetLatest } from "../../core/types.ts";
 
 /** Config for {@link ghReleaseUpdateGetLatest}. */
 export interface GhReleaseUpdateConfig {

package/src/configure/artifacts/install-validate.test.ts

@@ -3,9 +3,9 @@ Tests for install/install-validate module behavior.
 */
 
 import { describe, expect, test } from "bun:test";
-import type { CliProgram } from "~/core/types.ts";
-import { CliSchemaValidationError } from "~/core/types.ts";
-import { cliValidateProgram } from "~/core/validate.ts";
+import type { CliProgram } from "../../core/types.ts";
+import { CliSchemaValidationError } from "../../core/types.ts";
+import { cliValidateProgram } from "../../core/validate.ts";
 
 const base: CliProgram = {
   key: "app",

package/src/configure/artifacts/mcp-config.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-import type { CliProgram } from "~/core/types.ts";
+import type { CliProgram } from "../../core/types.ts";
 
 export interface McpServerEntry {
   command: string;

package/src/configure/artifacts/mcp-opencode.test.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { CliProgram } from "~/core/types.ts";
+import type { CliProgram } from "../../core/types.ts";
 import {
   detectOpenCodeMcpConfigPath,
   expectedOpenCodeMcpEntry,

package/src/configure/artifacts/mcp-opencode.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { CliProgram } from "~/core/types.ts";
+import type { CliProgram } from "../../core/types.ts";
 import { expectedMcpEntry } from "./mcp-config.ts";
 
 export const OPENCODE_CONFIG_SCHEMA = "https://opencode.ai/config.json";

package/src/configure/artifacts/paths.ts

@@ -1,9 +1,9 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { CliProgram } from "~/core/types.ts";
-import { mcpServerId, sanitizeToolSegment } from "~/mcp/tools.ts";
-import { displayHomePath, userHome, xdgConfigHome } from "~/paths/host.ts";
-import { skillDirNameForTarget } from "~/skill/install.ts";
+import type { CliProgram } from "../../core/types.ts";
+import { mcpServerId, sanitizeToolSegment } from "../../mcp/tools.ts";
+import { displayHomePath, userHome, xdgConfigHome } from "../../paths/host.ts";
+import { skillDirNameForTarget } from "../../skill/install.ts";
 import { resolveOpenclawConfigPath } from "./mcp-openclaw.ts";
 import { resolveOpenCodeConfigPathForInstall } from "./mcp-opencode.ts";
 
@@ -24,7 +24,7 @@ export interface InstallPaths {
   skillDirName: string;
 }
 
-export { userHome } from "~/paths/host.ts";
+export { userHome } from "../../paths/host.ts";
 
 /** Format an absolute path for user-facing install output. */
 export function displayInstallPath(path: string): string {

package/src/configure/artifacts/plan.ts

@@ -1,4 +1,4 @@
-import type { CliProgram } from "~/core/types.ts";
+import type { CliProgram } from "../../core/types.ts";
 import type { InstallPaths } from "./paths.ts";
 import { buildInstallPlanFromTargets } from "./target-plan-build.ts";
 import type { InstallAction, InstallOpts } from "./target-types.ts";

package/src/configure/artifacts/status.test.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { CliProgram } from "~/core/types.ts";
+import type { CliProgram } from "../../core/types.ts";
 import { resolveInstallPaths } from "./paths.ts";
 import { printInstallStatus } from "./status.ts";
 import { resolveInstallTargetPreview } from "./target-scope.ts";