argsbarg 5.1.7 → 5.1.9

package/src/config/context.test.ts

@@ -79,4 +79,49 @@ describe("config/context", () => {
     expect(ctx.dir).toBe(resolveAppConfigDir(program));
     expect(ctx.dir).toBe(dirname(ctx.path));
   });
+
+  test("AppConfigSnapshot unsafe read/write", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-unsafe-"));
+    const prevHome = process.env.HOME;
+    process.env.HOME = dir;
+    const prevToken = process.env.API_TOKEN;
+    delete process.env.API_TOKEN;
+    try {
+      const fileData = { apiToken: "tok" };
+      const resolved = resolveAppConfig(program, fileData);
+      const ctx = createAppConfigSnapshot(program, fileData, resolved);
+      expect(ctx.getUnsafe("apiToken")).toBe("tok");
+      expect(ctx.readUnsafe().apiToken).toBe("tok");
+      ctx.setUnsafe("note", "raw");
+      expect(ctx.getUnsafe("note")).toBe("raw");
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      if (prevToken === undefined) delete process.env.API_TOKEN;
+      else process.env.API_TOKEN = prevToken;
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("EmptyAppConfigSnapshot unsafe read/write", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-empty-unsafe-"));
+    const prevHome = process.env.HOME;
+    process.env.HOME = dir;
+    try {
+      const programWithoutConfig: CliProgram = {
+        key: "rawapp",
+        version: "1.0.0",
+        description: "No config.",
+        handler: () => {},
+      };
+      const empty = createAppConfigSnapshot(programWithoutConfig, {}, {});
+      empty.setUnsafe("custom", 42);
+      expect(empty.getUnsafe("custom")).toBe(42);
+      expect(empty.readUnsafe().custom).toBe(42);
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
 });

package/src/config/context.ts

@@ -3,13 +3,36 @@ Handler-facing resolved app config snapshot (ctx.appConfig).
 */
 
 import type { CliProgram } from "../types.ts";
-import { resolveAppConfigDir, resolveAppConfigPath, writeAppConfigFile } from "./file.ts";
+import { isFrameworkConfigKey, setBinding } from "./bindings.ts";
+import {
+  readAppConfigFileRaw,
+  resolveAppConfigDir,
+  resolveAppConfigPath,
+  writeAppConfigFile,
+  writeAppConfigFileRaw,
+} from "./file.ts";
 import type { ResolvedConfig } from "./resolve.ts";
 import { captureMappedHostEnv, exportConfigToEnv, resolveAppConfig } from "./resolve.ts";
+import { configPropertySchema, effectiveJsonSchema } from "./schema.ts";
+import { validateParsedConfigValue } from "./validate.ts";
+
+function rebuildResolved(program: CliProgram, fileData: Record<string, unknown>): ResolvedConfig {
+  const hostEnv = captureMappedHostEnv(program);
+  const resolved = resolveAppConfig(program, fileData, hostEnv);
+  exportConfigToEnv(program, resolved, hostEnv);
+  return resolved;
+}
 
 /** Empty snapshot when program.appConfig is not set. */
 export class EmptyAppConfigSnapshot {
-  constructor(private readonly program: CliProgram) {}
+  private fileData: Record<string, unknown>;
+
+  constructor(
+    private readonly program: CliProgram,
+    fileData?: Record<string, unknown>,
+  ) {
+    this.fileData = fileData ?? readAppConfigFileRaw(resolveAppConfigPath(program));
+  }
 
   get(_key: string): undefined {
     return undefined;
@@ -27,6 +50,20 @@ export class EmptyAppConfigSnapshot {
     return {};
   }
 
+  readUnsafe(): Record<string, unknown> {
+    return { ...this.fileData };
+  }
+
+  getUnsafe(key: string): unknown {
+    return this.fileData[key];
+  }
+
+  setUnsafe(key: string, value: unknown): void {
+    const next = { ...this.fileData, [key]: value };
+    writeAppConfigFileRaw(this.program, next);
+    this.fileData = next;
+  }
+
   /** Resolved absolute path to the app JSON config file (OS default from `program.key`). */
   get path(): string {
     return resolveAppConfigPath(this.program);
@@ -59,11 +96,7 @@ export class AppConfigSnapshot {
 
   require(key: string): unknown {
     const value = this.get(key);
-    if (
-      value === undefined ||
-      value === null ||
-      (typeof value === "string" && value.length === 0)
-    ) {
+    if (value === undefined || value === null || (typeof value === "string" && value.length === 0)) {
       throw new Error(`Missing required configuration: ${key}`);
     }
     return value;
@@ -71,18 +104,34 @@ export class AppConfigSnapshot {
 
   set(key: string, value: unknown): void {
     this.assertEntryKey(key);
-    const hostEnv = captureMappedHostEnv(this.program);
-    const next = { ...this.fileData, [key]: value };
-    writeAppConfigFile(this.program, next);
-    this.fileData = next;
-    this.snapshot = resolveAppConfig(this.program, next, hostEnv);
-    exportConfigToEnv(this.program, this.snapshot, hostEnv);
+    const jsonSchema = effectiveJsonSchema(this.program);
+    if (!jsonSchema) {
+      throw new Error("Internal error: missing effective jsonSchema.");
+    }
+    const propSchema = configPropertySchema(jsonSchema, key);
+    validateParsedConfigValue(value, propSchema, jsonSchema);
+    const next = setBinding({ ...this.fileData, [key]: value }, key, "file");
+    this.persistFileData(next);
   }
 
   read(): ResolvedConfig {
     return { ...this.snapshot };
   }
 
+  readUnsafe(): Record<string, unknown> {
+    return { ...this.fileData };
+  }
+
+  getUnsafe(key: string): unknown {
+    return this.fileData[key];
+  }
+
+  setUnsafe(key: string, value: unknown): void {
+    this.assertUnsafeKey(key);
+    const next = { ...this.fileData, [key]: value };
+    this.persistFileData(next);
+  }
+
   /** Resolved absolute path to the app JSON config file (`~/.local/lib/<key>/config.json`). */
   get path(): string {
     return resolveAppConfigPath(this.program);
@@ -99,12 +148,23 @@ export class AppConfigSnapshot {
     this.snapshot = { ...resolved };
   }
 
+  private persistFileData(next: Record<string, unknown>): void {
+    writeAppConfigFile(this.program, next, { partial: true });
+    this.fileData = next;
+    this.snapshot = rebuildResolved(this.program, next);
+  }
+
   private assertEntryKey(key: string): void {
     const entries = this.program.appConfig?.entries;
     if (!entries || !(key in entries)) {
       throw new Error(`Unknown configuration key: ${key}`);
     }
   }
+
+  private assertUnsafeKey(key: string): void {
+    if (isFrameworkConfigKey(key)) return;
+    this.assertEntryKey(key);
+  }
 }
 
 export type AnyAppConfigSnapshot = AppConfigSnapshot | EmptyAppConfigSnapshot;
@@ -115,7 +175,7 @@ export function createAppConfigSnapshot(
   resolved: ResolvedConfig,
 ): AnyAppConfigSnapshot {
   if (!program.appConfig) {
-    return new EmptyAppConfigSnapshot(program);
+    return new EmptyAppConfigSnapshot(program, fileData);
   }
   return new AppConfigSnapshot(program, fileData, resolved);
 }

package/src/config/entry.ts

@@ -46,9 +46,7 @@ export function configUserConfigKey(key: string): string {
 }
 
 /** Required keys from a JSON Schema object root. */
-export function jsonSchemaRequiredKeys(
-  jsonSchema: Record<string, unknown>,
-): Set<string> | undefined {
+export function jsonSchemaRequiredKeys(jsonSchema: Record<string, unknown>): Set<string> | undefined {
   const required = jsonSchema.required;
   if (!Array.isArray(required)) {
     return undefined;

package/src/config/file.test.ts

@@ -7,13 +7,17 @@ import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import type { CliProgram } from "../types.ts";
+import { CONFIG_BINDINGS_KEY } from "./bindings.ts";
 import { bootstrapAppConfig } from "./bootstrap.ts";
 import {
+  appConfigFileExists,
+  ensureAppConfigFile,
   readAppConfigFile,
   resolveAppConfigDir,
   resolveAppConfigPath,
   uninstallAppConfig,
   writeAppConfigFile,
+  writeAppConfigFileRaw,
 } from "./file.ts";
 import { buildProgramUserConfig } from "./manifest.ts";
 import { formatMissingConfigMessage, missingRequiredConfig, resolveAppConfig } from "./resolve.ts";
@@ -58,9 +62,7 @@ describe("config/file", () => {
 
   test("resolveAppConfigPath uses config.json", () => {
     withHome((home) => {
-      expect(resolveAppConfigPath(program)).toBe(
-        join(home, ".local", "lib", "myapp", "config.json"),
-      );
+      expect(resolveAppConfigPath(program)).toBe(join(home, ".local", "lib", "myapp", "config.json"));
     });
   });
 
@@ -126,4 +128,45 @@ describe("config/file", () => {
       expect(existsSync(configDir)).toBe(false);
     });
   });
+
+  test("ensureAppConfigFile creates empty config", () => {
+    withHome(() => {
+      const created = ensureAppConfigFile(program);
+      expect(created).toBe(resolveAppConfigPath(program));
+      expect(appConfigFileExists(program)).toBe(true);
+      expect(readAppConfigFile(program)).toEqual({});
+    });
+  });
+
+  test("ensureAppConfigFile no-op when file exists", () => {
+    withHome(() => {
+      writeAppConfigFileRaw(program, { apiToken: "x" });
+      expect(ensureAppConfigFile(program)).toBeNull();
+    });
+  });
+
+  test("read allows _bindings framework key", () => {
+    withHome(() => {
+      writeAppConfigFileRaw(program, {
+        [CONFIG_BINDINGS_KEY]: { apiToken: "env" },
+      });
+      expect(readAppConfigFile(program)).toEqual({
+        [CONFIG_BINDINGS_KEY]: { apiToken: "env" },
+      });
+    });
+  });
+
+  test("partial write allows bindings without required keys", () => {
+    withHome(() => {
+      writeAppConfigFile(program, { [CONFIG_BINDINGS_KEY]: { apiToken: "env" } }, { partial: true });
+      expect(readAppConfigFile(program)[CONFIG_BINDINGS_KEY]).toEqual({ apiToken: "env" });
+    });
+  });
+
+  test("appConfigFileExists false when only directory exists", () => {
+    withHome(() => {
+      mkdirSync(resolveAppConfigDir(program), { recursive: true });
+      expect(appConfigFileExists(program)).toBe(false);
+    });
+  });
 });

package/src/config/file.ts

@@ -7,8 +7,9 @@ import { dirname, join } from "node:path";
 import { sanitizeToolSegment } from "../mcp/tools.ts";
 import { appConfigLibHome, displayHomePath } from "../paths/host.ts";
 import type { CliProgram } from "../types.ts";
+import { isFrameworkConfigKey, validateBindingsShape } from "./bindings.ts";
 import { effectiveJsonSchema } from "./schema.ts";
-import { validateConfigDocument } from "./validate.ts";
+import { validateConfigDocument, validateConfigDocumentPartial } from "./validate.ts";
 
 export type AppConfigFileData = Record<string, unknown>;
 
@@ -56,15 +57,13 @@ export function readAppConfigFileRaw(path: string): AppConfigFileData {
   return parseConfigJson(text, path);
 }
 
-/** Read and validate config file against program schema. */
-export function readAppConfigFile(program: CliProgram): AppConfigFileData {
-  const path = resolveAppConfigPath(program);
-  const data = readAppConfigFileRaw(path);
-  if (Object.keys(data).length === 0) {
-    return data;
-  }
-  validateAppConfigData(program, data, path);
-  return data;
+function isEmptyConfigDocument(data: AppConfigFileData): boolean {
+  return Object.keys(data).every((k) => isFrameworkConfigKey(k));
+}
+
+/** True when `config.json` exists on disk. */
+export function appConfigFileExists(program: CliProgram): boolean {
+  return existsSync(resolveAppConfigPath(program));
 }
 
 /** Validate in-memory config data; throws on failure. */
@@ -72,15 +71,21 @@ export function validateAppConfigData(
   program: CliProgram,
   data: AppConfigFileData,
   pathLabel?: string,
+  opts: { partial?: boolean } = {},
 ): void {
   const appConfig = program.appConfig;
   if (!appConfig) {
     throw new Error("program.appConfig is not set");
   }
+  const where = pathLabel ? displayHomePath(pathLabel) : "config";
+  const bindingErrors = validateBindingsShape(data);
+  if (bindingErrors.length > 0) {
+    throw new Error(`Invalid config in ${where}: ${bindingErrors.join("; ")}`);
+  }
   const allowed = new Set(Object.keys(appConfig.entries));
   for (const key of Object.keys(data)) {
+    if (isFrameworkConfigKey(key)) continue;
     if (!allowed.has(key)) {
-      const where = pathLabel ? displayHomePath(pathLabel) : "config";
       throw new Error(`Unknown config key '${key}' in ${where}`);
     }
   }
@@ -88,26 +93,61 @@ export function validateAppConfigData(
   if (!jsonSchema) {
     return;
   }
+  if (opts.partial || isEmptyConfigDocument(data)) {
+    const result = validateConfigDocumentPartial(data, jsonSchema);
+    if (!result.valid) {
+      throw new Error(`Invalid config in ${where}: ${result.errors.join("; ")}`);
+    }
+    return;
+  }
   const result = validateConfigDocument(data, jsonSchema);
   if (!result.valid) {
-    const where = pathLabel ? displayHomePath(pathLabel) : "config";
     throw new Error(`Invalid config in ${where}: ${result.errors.join("; ")}`);
   }
 }
 
-/** Merge-write schema keys to the config file (`0o600`). */
-export function writeAppConfigFile(program: CliProgram, data: AppConfigFileData): void {
-  validateAppConfigData(program, data, displayAppConfigPath(program));
+/** Write JSON to the config path without schema validation (`0o600`). */
+export function writeAppConfigFileRaw(program: CliProgram, data: AppConfigFileData, dry = false): void {
   const path = resolveAppConfigPath(program);
+  if (dry) return;
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
 }
 
-/** True when the app config file or config directory is present. */
-export function appConfigInstalled(program: CliProgram): boolean {
+/** Create `config.json` as `{}` when missing; returns absolute path if created. */
+export function ensureAppConfigFile(program: CliProgram, dry = false): string | null {
+  const path = resolveAppConfigPath(program);
+  if (existsSync(path)) {
+    return null;
+  }
+  writeAppConfigFileRaw(program, {}, dry);
+  return path;
+}
+
+/** Read and validate config file against program schema. */
+export function readAppConfigFile(program: CliProgram): AppConfigFileData {
   const path = resolveAppConfigPath(program);
-  if (existsSync(path)) return true;
-  return existsSync(resolveAppConfigDir(program));
+  const data = readAppConfigFileRaw(path);
+  if (isEmptyConfigDocument(data)) {
+    return data;
+  }
+  validateAppConfigData(program, data, path);
+  return data;
+}
+
+/** Merge-write schema keys to the config file (`0o600`). */
+export function writeAppConfigFile(
+  program: CliProgram,
+  data: AppConfigFileData,
+  opts: { partial?: boolean } = {},
+): void {
+  validateAppConfigData(program, data, displayAppConfigPath(program), opts);
+  writeAppConfigFileRaw(program, data);
+}
+
+/** True when the app config file is present. */
+export function appConfigInstalled(program: CliProgram): boolean {
+  return appConfigFileExists(program);
 }
 
 /** Removes the app config file and config directory when present. */

package/src/config/resolve.ts

@@ -35,10 +35,7 @@ export function captureMappedHostEnv(program: CliProgram): Record<string, string
   return out;
 }
 
-function envOverrideValue(
-  envName: string,
-  hostEnv?: Record<string, string | undefined>,
-): string | undefined {
+function envOverrideValue(envName: string, hostEnv?: Record<string, string | undefined>): string | undefined {
   const val = hostEnv && envName in hostEnv ? hostEnv[envName] : process.env[envName];
   if (val === undefined || val.length === 0) {
     return undefined;

package/src/config/schema.ts

@@ -6,9 +6,7 @@ import type { CliAppConfigEntry, CliProgram } from "../types.ts";
 import { configEntryRequired, jsonSchemaRequiredKeys } from "./entry.ts";
 
 /** Synthesize a draft-07 object schema with string properties from metadata entries. */
-export function synthesizeAllStringSchema(
-  schema: Record<string, CliAppConfigEntry>,
-): Record<string, unknown> {
+export function synthesizeAllStringSchema(schema: Record<string, CliAppConfigEntry>): Record<string, unknown> {
   const properties: Record<string, unknown> = {};
   const required: string[] = [];
   for (const [key, entry] of Object.entries(schema)) {

package/src/config/validate.test.ts

@@ -24,10 +24,7 @@ const rootSchema = {
 /** Tests for config/validate. */
 describe("config/validate", () => {
   test("accepts valid document", () => {
-    const result = validateConfigDocument(
-      { apiToken: "x", maxRetries: 3, prefs: { ttl: 3600 } },
-      rootSchema,
-    );
+    const result = validateConfigDocument({ apiToken: "x", maxRetries: 3, prefs: { ttl: 3600 } }, rootSchema);
     expect(result.valid).toBe(true);
     expect(result.errors).toEqual([]);
   });
@@ -39,10 +36,7 @@ describe("config/validate", () => {
   });
 
   test("rejects unknown property when additionalProperties is false", () => {
-    const result = validateConfigDocument(
-      { apiToken: "x", maxRetries: 1, extra: true },
-      rootSchema,
-    );
+    const result = validateConfigDocument({ apiToken: "x", maxRetries: 1, extra: true }, rootSchema);
     expect(result.valid).toBe(false);
     expect(result.errors.some((e) => e.includes("extra"))).toBe(true);
   });
@@ -58,9 +52,7 @@ describe("config/validate", () => {
   });
 
   test("parseConfigSetValue requires --json for objects", () => {
-    expect(() => parseConfigSetValue("ttl:1", { type: "object" }, rootSchema, false)).toThrow(
-      /--json/,
-    );
+    expect(() => parseConfigSetValue("ttl:1", { type: "object" }, rootSchema, false)).toThrow(/--json/);
     expect(parseConfigSetValue('{"ttl":1}', { type: "object" }, rootSchema, true)).toEqual({
       ttl: 1,
     });

package/src/config/validate.ts

@@ -4,6 +4,7 @@ Aligned with common ts-json-schema-generator output (local $ref, objects, scalar
 */
 
 import { parseCommaList, parseDate, parseDateTime } from "../formats.ts";
+import { isFrameworkConfigKey } from "./bindings.ts";
 
 type JsonSchema = Record<string, unknown>;
 
@@ -21,7 +22,14 @@ export interface ValidateResult {
 /** 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);
+  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 };
 }
 
@@ -31,6 +39,7 @@ function validateValue(
   root: JsonSchema,
   path: string,
   errors: string[],
+  partial: boolean,
 ): void {
   const resolved = resolveSchema(schema, root);
   if (!resolved) {
@@ -59,7 +68,7 @@ function validateValue(
         continue;
       }
       const branchErrs: string[] = [];
-      validateValue(value, branch as JsonSchema, root, path, branchErrs);
+      validateValue(value, branch as JsonSchema, root, path, branchErrs, partial);
       if (branchErrs.length === 0) {
         return;
       }
@@ -93,10 +102,10 @@ function validateValue(
     errors.push(`${path}: must be null`);
   }
   if (types.includes("object") || (types.length === 0 && isPlainObject(value))) {
-    validateObject(value, resolved, root, path, errors);
+    validateObject(value, resolved, root, path, errors, partial);
   }
   if (types.includes("array") || (types.length === 0 && Array.isArray(value))) {
-    validateArray(value, resolved, root, path, errors);
+    validateArray(value, resolved, root, path, errors, partial);
   }
 }
 
@@ -165,13 +174,7 @@ function validateString(value: unknown, schema: JsonSchema, path: string, errors
   }
 }
 
-function validateNumber(
-  value: unknown,
-  schema: JsonSchema,
-  path: string,
-  errors: string[],
-  integer: boolean,
-): void {
+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`);
     return;
@@ -193,6 +196,7 @@ function validateObject(
   root: JsonSchema,
   path: string,
   errors: string[],
+  partial: boolean,
 ): void {
   if (!isPlainObject(value)) {
     errors.push(`${path}: must be object`);
@@ -207,22 +211,25 @@ function validateObject(
   if (propMap) {
     for (const [key, propSchema] of Object.entries(propMap)) {
       if (key in value) {
-        validateValue(value[key], propSchema, root, `${path}.${key}`, errors);
+        validateValue(value[key], propSchema, root, `${path}.${key}`, errors, 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}'`);
+  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}'`);
+        }
       }
     }
   }
 
   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}'`);
       }
@@ -236,6 +243,7 @@ function validateArray(
   root: JsonSchema,
   path: string,
   errors: string[],
+  partial: boolean,
 ): void {
   if (!Array.isArray(value)) {
     errors.push(`${path}: must be array`);
@@ -250,12 +258,12 @@ function validateArray(
   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);
+      validateValue(value[i], items as JsonSchema, root, `${path}[${i}]`, errors, partial);
     }
   }
 }
 
-function validateParsedConfigValue(
+export function validateParsedConfigValue(
   parsed: unknown,
   propertySchema: JsonSchema | undefined,
   rootSchema: JsonSchema,
@@ -264,18 +272,14 @@ function validateParsedConfigValue(
     return parsed;
   }
   const errors: string[] = [];
-  validateValue(parsed, propertySchema, rootSchema, "$", errors);
+  validateValue(parsed, propertySchema, rootSchema, "$", errors, false);
   if (errors.length > 0) {
     throw new Error(errors[0] ?? "Invalid config value");
   }
   return parsed;
 }
 
-function parseJsonLiteral(
-  raw: string,
-  propertySchema: JsonSchema | undefined,
-  rootSchema: JsonSchema,
-): unknown {
+function parseJsonLiteral(raw: string, propertySchema: JsonSchema | undefined, rootSchema: JsonSchema): unknown {
   let parsed: unknown;
   try {
     parsed = JSON.parse(raw) as unknown;
@@ -346,11 +350,7 @@ function parsePrimitiveArraySegment(segment: string, items: PrimitiveArrayItems)
   }
 }
 
-function parseHomogeneousPrimitiveArray(
-  raw: string,
-  arraySchema: JsonSchema,
-  rootSchema: JsonSchema,
-): unknown[] {
+function parseHomogeneousPrimitiveArray(raw: string, arraySchema: JsonSchema, rootSchema: JsonSchema): unknown[] {
   const items = homogeneousPrimitiveArrayItems(arraySchema, rootSchema);
   if (!items) {
     throw new Error("Use --json for object or array config values");

package/src/config.integration.test.ts

@@ -85,11 +85,7 @@ test("MCP config file loads and exports vars for tool handlers", async () => {
   const dir = mkdtempSync(join(tmpdir(), "argsbarg-mcp-"));
   const configFile = join(dir, ".local", "lib", "mcp_test", "config");
   mkdirSync(dirname(configFile), { recursive: true });
-  writeFileSync(
-    configFile,
-    `${JSON.stringify({ argsTestSecret: "file-value" }, null, 2)}\n`,
-    "utf8",
-  );
+  writeFileSync(configFile, `${JSON.stringify({ argsTestSecret: "file-value" }, null, 2)}\n`, "utf8");
   const responses = await mcpRequest(
     [
       {

package/src/configure/configure.test.ts

@@ -6,11 +6,9 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import {
-  appConfigHasEntries,
-  parseConfigureOpts,
-  validateConfigureOpts,
-} from "../configure/index.ts";
+import { appConfigFileExists } from "../config/file.ts";
+import { appConfigHasEntries, parseConfigureOpts, validateConfigureOpts } from "../configure/index.ts";
+import { Cli } from "../index.ts";
 import { detectInstalledArtifacts } from "../install/detect-installed.ts";
 import { parseInstallOpts } from "../install/opts.ts";
 import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "../install/paths.ts";
@@ -157,3 +155,19 @@ describe("app config wizard", () => {
     expect(appConfigHasEntries(fixture)).toBe(false);
   });
 });
+
+describe("configure --sync bootstrap", () => {
+  test("creates config.json for apps without appConfig", async () => {
+    const program: CliProgram = {
+      key: "syncboot",
+      version: "0.0.0",
+      description: "Sync bootstrap test.",
+      handler: () => {},
+      configure: { enabled: true },
+    };
+    expect(appConfigFileExists(program)).toBe(false);
+    const result = await new Cli(program).invoke(["configure", "--sync", "--yes"]);
+    expect(result.exitCode).toBe(0);
+    expect(appConfigFileExists(program)).toBe(true);
+  });
+});