@agimon-ai/po-config 0.0.0-alpha.0

package/dist/apiContracts.mjs

@@ -0,0 +1,198 @@
+import { defineApiContract, jsonApiResponses } from "@agimon-ai/po-core/apiContracts";
+import { Type } from "typebox";
+//#region src/schemas/apiContracts.ts
+const Text = Type.String();
+const Optional = Type.Optional;
+const Strings = Type.Array(Text);
+const NullableText = Type.Union([Text, Type.Null()]);
+const Scope = Type.Union([Type.Literal("global"), Type.Literal("repository")]);
+const Origin = Type.Union([
+	Type.Literal("global"),
+	Type.Literal("repository"),
+	Type.Literal("default")
+]);
+const SettingsConfigSchema = Type.Object({
+	repoRoot: Text,
+	hashes: Type.Object({
+		global: Text,
+		repository: Text
+	}),
+	values: Type.Record(Text, Type.Object({
+		value: Optional(Text),
+		origin: Origin,
+		scope: Type.Union([Scope, Type.Literal("both")])
+	}))
+});
+const SettingsEditSchema = Type.Object({
+	keyPath: Strings,
+	value: Type.Union([
+		Text,
+		Type.Number(),
+		Type.Null()
+	])
+});
+const SettingsWriteSchema = Type.Union([Type.Object({
+	repoRoot: Text,
+	scope: Scope,
+	...SettingsEditSchema.properties,
+	expectedHash: Text
+}), Type.Object({
+	repoRoot: Text,
+	scope: Scope,
+	edits: Type.Array(SettingsEditSchema, {
+		minItems: 1,
+		maxItems: 100
+	}),
+	expectedHash: Text
+})]);
+const Repository = Type.Object({
+	id: Text,
+	name: Text,
+	path: Text,
+	active: Type.Boolean()
+});
+const Catalog = Type.Array(Type.Object({
+	name: Text,
+	description: Optional(Text),
+	expandsTo: Optional(Strings),
+	layers: Optional(Strings)
+}));
+const SelectionText = Type.Object({
+	effective: Optional(Text),
+	repository: Optional(Text),
+	origin: Origin
+});
+const SelectionStrings = Type.Object({
+	effective: Optional(Strings),
+	repository: Optional(Strings),
+	origin: Origin
+});
+const RepositorySettingsSchema = Type.Object({
+	repository: Repository,
+	hash: Text,
+	catalogs: Type.Object({
+		majorModes: Catalog,
+		domains: Catalog,
+		profiles: Catalog
+	}),
+	selection: Type.Object({
+		majorMode: SelectionText,
+		domains: SelectionStrings,
+		profile: SelectionText
+	})
+});
+const RepositorySelectionWriteSchema = Type.Object({
+	repositoryId: Text,
+	expectedHash: Text,
+	changes: Type.Object({
+		majorMode: Optional(NullableText),
+		domains: Optional(Type.Union([Strings, Type.Null()])),
+		profile: Optional(NullableText)
+	})
+});
+const Images = Type.Object({
+	autoResize: Type.Boolean(),
+	maxDimension: Type.Number(),
+	minDimension: Type.Number(),
+	maxAllowedDimension: Type.Number()
+});
+const http = ["global", "workspace"].flatMap((scope) => {
+	const common = {
+		scope,
+		basePath: "settings",
+		authentication: "owner"
+	};
+	return [
+		{
+			...common,
+			id: "config",
+			path: "/",
+			method: "GET",
+			description: "Read selected settings keys and file hashes.",
+			parameters: [{
+				name: "key",
+				in: "query",
+				required: false,
+				schema: Strings
+			}],
+			responses: jsonApiResponses(SettingsConfigSchema)
+		},
+		{
+			...common,
+			id: "value",
+			path: "/value",
+			method: "PUT",
+			description: "Write a setting with an optimistic file hash.",
+			body: {
+				contentType: "application/json",
+				required: true,
+				schema: SettingsWriteSchema
+			},
+			responses: jsonApiResponses(SettingsConfigSchema)
+		},
+		{
+			...common,
+			id: "repositories",
+			path: "/repositories",
+			method: "GET",
+			description: "List admitted repositories.",
+			responses: jsonApiResponses(Type.Object({ repositories: Type.Array(Repository) }))
+		},
+		{
+			...common,
+			id: "repository",
+			path: "/repository",
+			method: "GET",
+			description: "Read the mounted workspace catalog and selection.",
+			availability: "Requires a workspace mount; global returns 404.",
+			responses: jsonApiResponses(RepositorySettingsSchema)
+		},
+		{
+			...common,
+			id: "selection",
+			path: "/repository/selection",
+			method: "PUT",
+			description: "Update the mounted workspace selection.",
+			availability: "Requires a workspace mount; global returns 404.",
+			body: {
+				contentType: "application/json",
+				required: true,
+				schema: RepositorySelectionWriteSchema
+			},
+			responses: jsonApiResponses(RepositorySettingsSchema)
+		},
+		...scope === "global" ? [{
+			...common,
+			id: "images.get",
+			path: "/images",
+			method: "GET",
+			description: "Read image resizing limits.",
+			responses: jsonApiResponses(Images)
+		}, {
+			...common,
+			id: "images.put",
+			path: "/images",
+			method: "PUT",
+			description: "Update image resizing settings; dimensions are clamped.",
+			body: {
+				contentType: "application/json",
+				required: true,
+				schema: Type.Object({
+					autoResize: Optional(Type.Boolean()),
+					maxDimension: Optional(Type.Number())
+				})
+			},
+			responses: jsonApiResponses(Images)
+		}] : []
+	];
+});
+const apiContracts = defineApiContract({
+	version: 1,
+	http,
+	sockets: [],
+	dynamic: []
+});
+//#endregion
+export { apiContracts, apiContracts as default };
+
+//# sourceMappingURL=apiContracts.mjs.map

package/dist/apiContracts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.mjs","names":[],"sources":["../src/schemas/apiContracts.ts"],"sourcesContent":["import { defineApiContract, jsonApiResponses, type DoomHttpContract } from '@agimon-ai/po-core/apiContracts';\nimport { Type } from 'typebox';\n\nconst Text = Type.String();\nconst Optional = Type.Optional;\nconst Strings = Type.Array(Text);\nconst NullableText = Type.Union([Text, Type.Null()]);\nconst Scope = Type.Union([Type.Literal('global'), Type.Literal('repository')]);\nconst Origin = Type.Union([Type.Literal('global'), Type.Literal('repository'), Type.Literal('default')]);\nexport const SettingsConfigSchema = Type.Object({\n  repoRoot: Text,\n  hashes: Type.Object({ global: Text, repository: Text }),\n  values: Type.Record(\n    Text,\n    Type.Object({\n      value: Optional(Text),\n      origin: Origin,\n      scope: Type.Union([Scope, Type.Literal('both')]),\n    }),\n  ),\n});\nconst SettingsEditSchema = Type.Object({ keyPath: Strings, value: Type.Union([Text, Type.Number(), Type.Null()]) });\nexport const SettingsWriteSchema = Type.Union([\n  Type.Object({ repoRoot: Text, scope: Scope, ...SettingsEditSchema.properties, expectedHash: Text }),\n  Type.Object({\n    repoRoot: Text,\n    scope: Scope,\n    edits: Type.Array(SettingsEditSchema, { minItems: 1, maxItems: 100 }),\n    expectedHash: Text,\n  }),\n]);\n\nconst Repository = Type.Object({ id: Text, name: Text, path: Text, active: Type.Boolean() });\nconst Catalog = Type.Array(\n  Type.Object({ name: Text, description: Optional(Text), expandsTo: Optional(Strings), layers: Optional(Strings) }),\n);\nconst SelectionText = Type.Object({ effective: Optional(Text), repository: Optional(Text), origin: Origin });\nconst SelectionStrings = Type.Object({ effective: Optional(Strings), repository: Optional(Strings), origin: Origin });\nexport const RepositorySettingsSchema = Type.Object({\n  repository: Repository,\n  hash: Text,\n  catalogs: Type.Object({ majorModes: Catalog, domains: Catalog, profiles: Catalog }),\n  selection: Type.Object({ majorMode: SelectionText, domains: SelectionStrings, profile: SelectionText }),\n});\nexport const RepositorySelectionWriteSchema = Type.Object({\n  repositoryId: Text,\n  expectedHash: Text,\n  changes: Type.Object({\n    majorMode: Optional(NullableText),\n    domains: Optional(Type.Union([Strings, Type.Null()])),\n    profile: Optional(NullableText),\n  }),\n});\nconst Images = Type.Object({\n  autoResize: Type.Boolean(),\n  maxDimension: Type.Number(),\n  minDimension: Type.Number(),\n  maxAllowedDimension: Type.Number(),\n});\nconst http: DoomHttpContract[] = (['global', 'workspace'] as const).flatMap((scope) => {\n  const common = { scope, basePath: 'settings', authentication: 'owner' as const };\n  return [\n    {\n      ...common,\n      id: 'config',\n      path: '/',\n      method: 'GET',\n      description: 'Read selected settings keys and file hashes.',\n      parameters: [{ name: 'key', in: 'query', required: false, schema: Strings }],\n      responses: jsonApiResponses(SettingsConfigSchema),\n    },\n    {\n      ...common,\n      id: 'value',\n      path: '/value',\n      method: 'PUT',\n      description: 'Write a setting with an optimistic file hash.',\n      body: { contentType: 'application/json', required: true, schema: SettingsWriteSchema },\n      responses: jsonApiResponses(SettingsConfigSchema),\n    },\n    {\n      ...common,\n      id: 'repositories',\n      path: '/repositories',\n      method: 'GET',\n      description: 'List admitted repositories.',\n      responses: jsonApiResponses(Type.Object({ repositories: Type.Array(Repository) })),\n    },\n    {\n      ...common,\n      id: 'repository',\n      path: '/repository',\n      method: 'GET',\n      description: 'Read the mounted workspace catalog and selection.',\n      availability: 'Requires a workspace mount; global returns 404.',\n      responses: jsonApiResponses(RepositorySettingsSchema),\n    },\n    {\n      ...common,\n      id: 'selection',\n      path: '/repository/selection',\n      method: 'PUT',\n      description: 'Update the mounted workspace selection.',\n      availability: 'Requires a workspace mount; global returns 404.',\n      body: { contentType: 'application/json', required: true, schema: RepositorySelectionWriteSchema },\n      responses: jsonApiResponses(RepositorySettingsSchema),\n    },\n    ...(scope === 'global'\n      ? [\n          {\n            ...common,\n            id: 'images.get',\n            path: '/images',\n            method: 'GET' as const,\n            description: 'Read image resizing limits.',\n            responses: jsonApiResponses(Images),\n          },\n          {\n            ...common,\n            id: 'images.put',\n            path: '/images',\n            method: 'PUT' as const,\n            description: 'Update image resizing settings; dimensions are clamped.',\n            body: {\n              contentType: 'application/json',\n              required: true,\n              schema: Type.Object({ autoResize: Optional(Type.Boolean()), maxDimension: Optional(Type.Number()) }),\n            },\n            responses: jsonApiResponses(Images),\n          },\n        ]\n      : []),\n  ] satisfies DoomHttpContract[];\n});\nexport const apiContracts = defineApiContract({ version: 1, http, sockets: [], dynamic: [] });\nexport default apiContracts;\n"],"mappings":";;;AAGA,MAAM,OAAO,KAAK,OAAO;AACzB,MAAM,WAAW,KAAK;AACtB,MAAM,UAAU,KAAK,MAAM,IAAI;AAC/B,MAAM,eAAe,KAAK,MAAM,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC;AACnD,MAAM,QAAQ,KAAK,MAAM,CAAC,KAAK,QAAQ,QAAQ,GAAG,KAAK,QAAQ,YAAY,CAAC,CAAC;AAC7E,MAAM,SAAS,KAAK,MAAM;CAAC,KAAK,QAAQ,QAAQ;CAAG,KAAK,QAAQ,YAAY;CAAG,KAAK,QAAQ,SAAS;AAAC,CAAC;AACvG,MAAa,uBAAuB,KAAK,OAAO;CAC9C,UAAU;CACV,QAAQ,KAAK,OAAO;EAAE,QAAQ;EAAM,YAAY;CAAK,CAAC;CACtD,QAAQ,KAAK,OACX,MACA,KAAK,OAAO;EACV,OAAO,SAAS,IAAI;EACpB,QAAQ;EACR,OAAO,KAAK,MAAM,CAAC,OAAO,KAAK,QAAQ,MAAM,CAAC,CAAC;CACjD,CAAC,CACH;AACF,CAAC;AACD,MAAM,qBAAqB,KAAK,OAAO;CAAE,SAAS;CAAS,OAAO,KAAK,MAAM;EAAC;EAAM,KAAK,OAAO;EAAG,KAAK,KAAK;CAAC,CAAC;AAAE,CAAC;AAClH,MAAa,sBAAsB,KAAK,MAAM,CAC5C,KAAK,OAAO;CAAE,UAAU;CAAM,OAAO;CAAO,GAAG,mBAAmB;CAAY,cAAc;AAAK,CAAC,GAClG,KAAK,OAAO;CACV,UAAU;CACV,OAAO;CACP,OAAO,KAAK,MAAM,oBAAoB;EAAE,UAAU;EAAG,UAAU;CAAI,CAAC;CACpE,cAAc;AAChB,CAAC,CACH,CAAC;AAED,MAAM,aAAa,KAAK,OAAO;CAAE,IAAI;CAAM,MAAM;CAAM,MAAM;CAAM,QAAQ,KAAK,QAAQ;AAAE,CAAC;AAC3F,MAAM,UAAU,KAAK,MACnB,KAAK,OAAO;CAAE,MAAM;CAAM,aAAa,SAAS,IAAI;CAAG,WAAW,SAAS,OAAO;CAAG,QAAQ,SAAS,OAAO;AAAE,CAAC,CAClH;AACA,MAAM,gBAAgB,KAAK,OAAO;CAAE,WAAW,SAAS,IAAI;CAAG,YAAY,SAAS,IAAI;CAAG,QAAQ;AAAO,CAAC;AAC3G,MAAM,mBAAmB,KAAK,OAAO;CAAE,WAAW,SAAS,OAAO;CAAG,YAAY,SAAS,OAAO;CAAG,QAAQ;AAAO,CAAC;AACpH,MAAa,2BAA2B,KAAK,OAAO;CAClD,YAAY;CACZ,MAAM;CACN,UAAU,KAAK,OAAO;EAAE,YAAY;EAAS,SAAS;EAAS,UAAU;CAAQ,CAAC;CAClF,WAAW,KAAK,OAAO;EAAE,WAAW;EAAe,SAAS;EAAkB,SAAS;CAAc,CAAC;AACxG,CAAC;AACD,MAAa,iCAAiC,KAAK,OAAO;CACxD,cAAc;CACd,cAAc;CACd,SAAS,KAAK,OAAO;EACnB,WAAW,SAAS,YAAY;EAChC,SAAS,SAAS,KAAK,MAAM,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC;EACpD,SAAS,SAAS,YAAY;CAChC,CAAC;AACH,CAAC;AACD,MAAM,SAAS,KAAK,OAAO;CACzB,YAAY,KAAK,QAAQ;CACzB,cAAc,KAAK,OAAO;CAC1B,cAAc,KAAK,OAAO;CAC1B,qBAAqB,KAAK,OAAO;AACnC,CAAC;AACD,MAAM,OAA4B,CAAC,UAAU,WAAW,CAAC,CAAW,SAAS,UAAU;CACrF,MAAM,SAAS;EAAE;EAAO,UAAU;EAAY,gBAAgB;CAAiB;CAC/E,OAAO;EACL;GACE,GAAG;GACH,IAAI;GACJ,MAAM;GACN,QAAQ;GACR,aAAa;GACb,YAAY,CAAC;IAAE,MAAM;IAAO,IAAI;IAAS,UAAU;IAAO,QAAQ;GAAQ,CAAC;GAC3E,WAAW,iBAAiB,oBAAoB;EAClD;EACA;GACE,GAAG;GACH,IAAI;GACJ,MAAM;GACN,QAAQ;GACR,aAAa;GACb,MAAM;IAAE,aAAa;IAAoB,UAAU;IAAM,QAAQ;GAAoB;GACrF,WAAW,iBAAiB,oBAAoB;EAClD;EACA;GACE,GAAG;GACH,IAAI;GACJ,MAAM;GACN,QAAQ;GACR,aAAa;GACb,WAAW,iBAAiB,KAAK,OAAO,EAAE,cAAc,KAAK,MAAM,UAAU,EAAE,CAAC,CAAC;EACnF;EACA;GACE,GAAG;GACH,IAAI;GACJ,MAAM;GACN,QAAQ;GACR,aAAa;GACb,cAAc;GACd,WAAW,iBAAiB,wBAAwB;EACtD;EACA;GACE,GAAG;GACH,IAAI;GACJ,MAAM;GACN,QAAQ;GACR,aAAa;GACb,cAAc;GACd,MAAM;IAAE,aAAa;IAAoB,UAAU;IAAM,QAAQ;GAA+B;GAChG,WAAW,iBAAiB,wBAAwB;EACtD;EACA,GAAI,UAAU,WACV,CACE;GACE,GAAG;GACH,IAAI;GACJ,MAAM;GACN,QAAQ;GACR,aAAa;GACb,WAAW,iBAAiB,MAAM;EACpC,GACA;GACE,GAAG;GACH,IAAI;GACJ,MAAM;GACN,QAAQ;GACR,aAAa;GACb,MAAM;IACJ,aAAa;IACb,UAAU;IACV,QAAQ,KAAK,OAAO;KAAE,YAAY,SAAS,KAAK,QAAQ,CAAC;KAAG,cAAc,SAAS,KAAK,OAAO,CAAC;IAAE,CAAC;GACrG;GACA,WAAW,iBAAiB,MAAM;EACpC,CACF,IACA,CAAC;CACP;AACF,CAAC;AACD,MAAa,eAAe,kBAAkB;CAAE,SAAS;CAAG;CAAM,SAAS,CAAC;CAAG,SAAS,CAAC;AAAE,CAAC"}

package/dist/atomicJson-1W0WhuFF.mjs

@@ -0,0 +1,44 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/services/atomicJson/index.ts
+/**
+* Private atomic JSON writes.
+*
+* Write to a uniquely named temporary file in the destination directory, then
+* rename onto the target. Rename is atomic within a filesystem, so a reader
+* sees either the previous file or the complete new one and never a partial
+* write. The temporary name carries the pid and a random suffix, so two
+* processes writing the same target cannot collide on it.
+*
+* This prevents torn reads. It does NOT prevent lost updates: two writers doing
+* read-modify-write still clobber each other, because the rename only publishes
+* what the caller already computed. Harness state avoids that by giving every
+* process a file it owns rather than by locking.
+*
+* AVOID:
+* - Treating this as a lock
+* - Leaving the temporary file behind when the write fails
+*/
+const PRIVATE_FILE_MODE = 384;
+const PRIVATE_DIRECTORY_MODE = 448;
+const TEMPORARY_SUFFIX = ".tmp";
+/** Writes JSON readable by its owner only, replacing the target atomically. */
+function writePrivateAtomicJson(filePath, value) {
+	fs.mkdirSync(path.dirname(filePath), {
+		mode: PRIVATE_DIRECTORY_MODE,
+		recursive: true
+	});
+	const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}${TEMPORARY_SUFFIX}`;
+	try {
+		fs.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { mode: PRIVATE_FILE_MODE });
+		fs.renameSync(temporaryPath, filePath);
+	} catch (error) {
+		fs.rmSync(temporaryPath, { force: true });
+		throw error;
+	}
+}
+//#endregion
+export { writePrivateAtomicJson as t };
+
+//# sourceMappingURL=atomicJson-1W0WhuFF.mjs.map

package/dist/atomicJson-1W0WhuFF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomicJson-1W0WhuFF.mjs","names":[],"sources":["../src/services/atomicJson/index.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport fs from 'node:fs';\nimport path from 'node:path';\n\n/**\n * Private atomic JSON writes.\n *\n * Write to a uniquely named temporary file in the destination directory, then\n * rename onto the target. Rename is atomic within a filesystem, so a reader\n * sees either the previous file or the complete new one and never a partial\n * write. The temporary name carries the pid and a random suffix, so two\n * processes writing the same target cannot collide on it.\n *\n * This prevents torn reads. It does NOT prevent lost updates: two writers doing\n * read-modify-write still clobber each other, because the rename only publishes\n * what the caller already computed. Harness state avoids that by giving every\n * process a file it owns rather than by locking.\n *\n * AVOID:\n * - Treating this as a lock\n * - Leaving the temporary file behind when the write fails\n */\n\nconst PRIVATE_FILE_MODE = 0o600;\nconst PRIVATE_DIRECTORY_MODE = 0o700;\nconst TEMPORARY_SUFFIX = '.tmp';\n\n/** Writes JSON readable by its owner only, replacing the target atomically. */\nexport function writePrivateAtomicJson(filePath: string, value: unknown): void {\n  fs.mkdirSync(path.dirname(filePath), { mode: PRIVATE_DIRECTORY_MODE, recursive: true });\n  const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}${TEMPORARY_SUFFIX}`;\n  try {\n    fs.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\\n`, { mode: PRIVATE_FILE_MODE });\n    fs.renameSync(temporaryPath, filePath);\n  } catch (error) {\n    fs.rmSync(temporaryPath, { force: true });\n    throw error;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,oBAAoB;AAC1B,MAAM,yBAAyB;AAC/B,MAAM,mBAAmB;;AAGzB,SAAgB,uBAAuB,UAAkB,OAAsB;CAC7E,GAAG,UAAU,KAAK,QAAQ,QAAQ,GAAG;EAAE,MAAM;EAAwB,WAAW;CAAK,CAAC;CACtF,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,IAAI,GAAG,WAAW,IAAI;CACnE,IAAI;EACF,GAAG,cAAc,eAAe,GAAG,KAAK,UAAU,OAAO,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;EAClG,GAAG,WAAW,eAAe,QAAQ;CACvC,SAAS,OAAO;EACd,GAAG,OAAO,eAAe,EAAE,OAAO,KAAK,CAAC;EACxC,MAAM;CACR;AACF"}

package/dist/atomicJson-Dt2z_DXl.cjs

@@ -0,0 +1,52 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+//#region src/services/atomicJson/index.ts
+/**
+* Private atomic JSON writes.
+*
+* Write to a uniquely named temporary file in the destination directory, then
+* rename onto the target. Rename is atomic within a filesystem, so a reader
+* sees either the previous file or the complete new one and never a partial
+* write. The temporary name carries the pid and a random suffix, so two
+* processes writing the same target cannot collide on it.
+*
+* This prevents torn reads. It does NOT prevent lost updates: two writers doing
+* read-modify-write still clobber each other, because the rename only publishes
+* what the caller already computed. Harness state avoids that by giving every
+* process a file it owns rather than by locking.
+*
+* AVOID:
+* - Treating this as a lock
+* - Leaving the temporary file behind when the write fails
+*/
+const PRIVATE_FILE_MODE = 384;
+const PRIVATE_DIRECTORY_MODE = 448;
+const TEMPORARY_SUFFIX = ".tmp";
+/** Writes JSON readable by its owner only, replacing the target atomically. */
+function writePrivateAtomicJson(filePath, value) {
+	node_fs.default.mkdirSync(node_path.default.dirname(filePath), {
+		mode: PRIVATE_DIRECTORY_MODE,
+		recursive: true
+	});
+	const temporaryPath = `${filePath}.${process.pid}.${(0, node_crypto.randomUUID)()}${TEMPORARY_SUFFIX}`;
+	try {
+		node_fs.default.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { mode: PRIVATE_FILE_MODE });
+		node_fs.default.renameSync(temporaryPath, filePath);
+	} catch (error) {
+		node_fs.default.rmSync(temporaryPath, { force: true });
+		throw error;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "writePrivateAtomicJson", {
+	enumerable: true,
+	get: function() {
+		return writePrivateAtomicJson;
+	}
+});
+
+//# sourceMappingURL=atomicJson-Dt2z_DXl.cjs.map

package/dist/atomicJson-Dt2z_DXl.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomicJson-Dt2z_DXl.cjs","names":["path","randomUUID"],"sources":["../src/services/atomicJson/index.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport fs from 'node:fs';\nimport path from 'node:path';\n\n/**\n * Private atomic JSON writes.\n *\n * Write to a uniquely named temporary file in the destination directory, then\n * rename onto the target. Rename is atomic within a filesystem, so a reader\n * sees either the previous file or the complete new one and never a partial\n * write. The temporary name carries the pid and a random suffix, so two\n * processes writing the same target cannot collide on it.\n *\n * This prevents torn reads. It does NOT prevent lost updates: two writers doing\n * read-modify-write still clobber each other, because the rename only publishes\n * what the caller already computed. Harness state avoids that by giving every\n * process a file it owns rather than by locking.\n *\n * AVOID:\n * - Treating this as a lock\n * - Leaving the temporary file behind when the write fails\n */\n\nconst PRIVATE_FILE_MODE = 0o600;\nconst PRIVATE_DIRECTORY_MODE = 0o700;\nconst TEMPORARY_SUFFIX = '.tmp';\n\n/** Writes JSON readable by its owner only, replacing the target atomically. */\nexport function writePrivateAtomicJson(filePath: string, value: unknown): void {\n  fs.mkdirSync(path.dirname(filePath), { mode: PRIVATE_DIRECTORY_MODE, recursive: true });\n  const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}${TEMPORARY_SUFFIX}`;\n  try {\n    fs.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\\n`, { mode: PRIVATE_FILE_MODE });\n    fs.renameSync(temporaryPath, filePath);\n  } catch (error) {\n    fs.rmSync(temporaryPath, { force: true });\n    throw error;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,oBAAoB;AAC1B,MAAM,yBAAyB;AAC/B,MAAM,mBAAmB;;AAGzB,SAAgB,uBAAuB,UAAkB,OAAsB;CAC7E,QAAA,QAAG,UAAUA,UAAAA,QAAK,QAAQ,QAAQ,GAAG;EAAE,MAAM;EAAwB,WAAW;CAAK,CAAC;CACtF,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,IAAI,IAAA,GAAGC,YAAAA,WAAAA,CAAW,IAAI;CACnE,IAAI;EACF,QAAA,QAAG,cAAc,eAAe,GAAG,KAAK,UAAU,OAAO,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;EAClG,QAAA,QAAG,WAAW,eAAe,QAAQ;CACvC,SAAS,OAAO;EACd,QAAA,QAAG,OAAO,eAAe,EAAE,OAAO,KAAK,CAAC;EACxC,MAAM;CACR;AACF"}

package/dist/atomicJson.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_atomicJson = require("./atomicJson-Dt2z_DXl.cjs");
+exports.writePrivateAtomicJson = require_atomicJson.writePrivateAtomicJson;

package/dist/atomicJson.d.mts

@@ -0,0 +1,2 @@
+import { t as writePrivateAtomicJson } from "./index-C6GaYjq-.mjs";
+export { writePrivateAtomicJson };

package/dist/atomicJson.mjs

@@ -0,0 +1,2 @@
+import { t as writePrivateAtomicJson } from "./atomicJson-1W0WhuFF.mjs";
+export { writePrivateAtomicJson };

package/dist/config-BUw5kHsx.cjs

@@ -0,0 +1,219 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_configPolicy = require("./configPolicy-DmsZEp0t.cjs");
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os, 1);
+let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
+let yaml = require("yaml");
+//#region src/services/config/index.ts
+const DOOM_DIR = ".po";
+const CONFIG_FILE = "config.yaml";
+const PLANS_DIR = "plans";
+function readConfig(filePath) {
+	return node_fs.default.existsSync(filePath) ? require_configPolicy.parseDoomConfig(node_fs.default.readFileSync(filePath, "utf8"), filePath) : { projectTrust: "ask" };
+}
+async function readConfigAsync(filePath) {
+	try {
+		return require_configPolicy.parseDoomConfig(await node_fs.default.promises.readFile(filePath, "utf8"), filePath);
+	} catch (error) {
+		if (error.code === "ENOENT") return { projectTrust: "ask" };
+		throw error;
+	}
+}
+function globalDoomConfigDirectory(homeDirectory = node_os.default.homedir()) {
+	return (0, _agimon_ai_po_core_piSettings.poHomeDirectory)(homeDirectory);
+}
+function globalDoomConfigPath(homeDirectory = node_os.default.homedir()) {
+	return node_path.default.join(globalDoomConfigDirectory(homeDirectory), CONFIG_FILE);
+}
+function resolvePlanningPlansDirectory(configured, repoRoot, homeDirectory = node_os.default.homedir()) {
+	if (!configured) return node_path.default.join(globalDoomConfigDirectory(homeDirectory), PLANS_DIR);
+	if (configured === "~") return homeDirectory;
+	if (configured.startsWith("~/")) return node_path.default.resolve(homeDirectory, configured.slice(2));
+	if (configured.startsWith("~")) throw new Error("Doom planning plansDirectory supports only '~' or '~/' home aliases");
+	return node_path.default.isAbsolute(configured) ? node_path.default.normalize(configured) : node_path.default.resolve(repoRoot, configured);
+}
+function repositoryDoomConfigPath(repoRoot) {
+	return node_path.default.join(repoRoot, DOOM_DIR, CONFIG_FILE);
+}
+/**
+* True when a repository's `.po` folder is Po's home itself, as it is for a
+* session rooted at home. That folder is already the global layer; reading it
+* again as the repository layer would apply global-only keys at repository scope.
+*/
+function isGlobalDoomConfigRoot(repoRoot, homeDirectory = node_os.default.homedir()) {
+	return node_path.default.resolve(repoRoot, DOOM_DIR) === node_path.default.resolve(globalDoomConfigDirectory(homeDirectory));
+}
+function repositoryConfigFor(repoRoot, homeDirectory) {
+	return isGlobalDoomConfigRoot(repoRoot, homeDirectory) ? void 0 : repositoryDoomConfigPath(repoRoot);
+}
+/** Process-local distribution defaults never grant native authority or modify user files. */
+function distributionDefaults(config, environment) {
+	if (environment.PO_DISTRIBUTION !== "desktop") return config;
+	return {
+		...config,
+		computerUse: {
+			...config.computerUse,
+			enabled: config.computerUse?.enabled ?? true
+		}
+	};
+}
+function loadDoomConfig(repoRoot, homeDirectory = node_os.default.homedir(), environment = process.env) {
+	const repositoryPath = repositoryConfigFor(repoRoot, homeDirectory);
+	return distributionDefaults(require_configPolicy.mergeDoomConfigs(readConfig(globalDoomConfigPath(homeDirectory)), repositoryPath === void 0 ? { projectTrust: "ask" } : readConfig(repositoryPath)), environment);
+}
+/**
+* Loads the merged config, tolerating unknown keys in either file.
+*
+* Only `po sync` uses this. Everything that runs during a session keeps
+* `loadDoomConfig`, because a key a running extension cannot understand is
+* better reported than silently ignored; a build that refuses to start over
+* the same key is not.
+*/
+function loadDoomConfigLenient(repoRoot, homeDirectory = node_os.default.homedir(), environment = process.env) {
+	const read = (filePath) => filePath !== void 0 && node_fs.default.existsSync(filePath) ? require_configPolicy.parseDoomConfig(node_fs.default.readFileSync(filePath, "utf8"), filePath, { lenient: true }) : {
+		config: { projectTrust: "ask" },
+		diagnostics: []
+	};
+	const globalConfig = read(globalDoomConfigPath(homeDirectory));
+	const repositoryConfig = read(repositoryConfigFor(repoRoot, homeDirectory));
+	const diagnostics = [...globalConfig.diagnostics, ...repositoryConfig.diagnostics];
+	return {
+		config: distributionDefaults(require_configPolicy.mergeDoomConfigs(globalConfig.config, repositoryConfig.config), environment),
+		diagnostics
+	};
+}
+async function loadDoomConfigAsync(repoRoot, homeDirectory = node_os.default.homedir(), environment = process.env) {
+	const globalConfig = await readConfigAsync(globalDoomConfigPath(homeDirectory));
+	const repositoryPath = repositoryConfigFor(repoRoot, homeDirectory);
+	const repositoryConfig = repositoryPath === void 0 ? { projectTrust: "ask" } : await readConfigAsync(repositoryPath);
+	return distributionDefaults(require_configPolicy.mergeDoomConfigs(globalConfig, repositoryConfig), environment);
+}
+/**
+* Reads one config file as a layer: what it is, what it sets, and the bytes it
+* held. A file that does not exist is a layer that sets nothing, which is a
+* normal state rather than an error.
+*/
+function readLayer(filePath) {
+	let text;
+	try {
+		text = node_fs.default.readFileSync(filePath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			filePath,
+			exists: false,
+			hash: "",
+			keys: []
+		};
+		throw error;
+	}
+	const document = (0, yaml.parse)(text) ?? {};
+	return {
+		filePath,
+		exists: true,
+		hash: (0, node_crypto.createHash)("sha256").update(text, "utf8").digest("hex"),
+		keys: require_configPolicy.configLeafKeys(document)
+	};
+}
+/**
+* The two config files kept apart, with the merge alongside them.
+*
+* `repoRoot` is optional because the global file is complete on its own: a
+* settings surface with no repository in view still has settings to show, and
+* demanding one would leave it with nothing to render rather than with the
+* global half.
+*
+* The origin answer respects the merge's own per-field rules rather than simply
+* preferring the repository: `editor` is read from the global side whatever the
+* repository says, and `projectTrust` from the repository side whatever the
+* global one says. Reporting a file as the source of a value the merge discards
+* is the exact confusion this exists to remove.
+*/
+function loadDoomConfigLayers(repoRoot, homeDirectory = node_os.default.homedir(), environment = process.env) {
+	const globalLayer = readLayer(globalDoomConfigPath(homeDirectory));
+	const repositoryPath = repoRoot === void 0 ? void 0 : repositoryConfigFor(repoRoot, homeDirectory);
+	const repositoryLayer = repositoryPath === void 0 ? {
+		filePath: "",
+		exists: false,
+		hash: "",
+		keys: []
+	} : readLayer(repositoryPath);
+	const effective = repoRoot === void 0 ? distributionDefaults(require_configPolicy.mergeDoomConfigs(readConfig(globalDoomConfigPath(homeDirectory)), { projectTrust: "ask" }), environment) : loadDoomConfig(repoRoot, homeDirectory, environment);
+	const sets = (layer, keyPath) => {
+		const dotted = keyPath.join(".");
+		return layer.keys.some((key) => key === dotted || key.startsWith(`${dotted}.`));
+	};
+	return {
+		globalFile: globalLayer,
+		repositoryFile: repositoryLayer,
+		effective,
+		originOf(keyPath) {
+			const scope = require_configPolicy.configScopeOf(keyPath);
+			if (scope !== "global" && sets(repositoryLayer, keyPath)) return "repository";
+			if (scope !== "repository" && sets(globalLayer, keyPath)) return "global";
+			return "default";
+		},
+		valueAt: (keyPath) => require_configPolicy.valueAtKeyPath(effective, keyPath)
+	};
+}
+//#endregion
+Object.defineProperty(exports, "globalDoomConfigDirectory", {
+	enumerable: true,
+	get: function() {
+		return globalDoomConfigDirectory;
+	}
+});
+Object.defineProperty(exports, "globalDoomConfigPath", {
+	enumerable: true,
+	get: function() {
+		return globalDoomConfigPath;
+	}
+});
+Object.defineProperty(exports, "isGlobalDoomConfigRoot", {
+	enumerable: true,
+	get: function() {
+		return isGlobalDoomConfigRoot;
+	}
+});
+Object.defineProperty(exports, "loadDoomConfig", {
+	enumerable: true,
+	get: function() {
+		return loadDoomConfig;
+	}
+});
+Object.defineProperty(exports, "loadDoomConfigAsync", {
+	enumerable: true,
+	get: function() {
+		return loadDoomConfigAsync;
+	}
+});
+Object.defineProperty(exports, "loadDoomConfigLayers", {
+	enumerable: true,
+	get: function() {
+		return loadDoomConfigLayers;
+	}
+});
+Object.defineProperty(exports, "loadDoomConfigLenient", {
+	enumerable: true,
+	get: function() {
+		return loadDoomConfigLenient;
+	}
+});
+Object.defineProperty(exports, "repositoryDoomConfigPath", {
+	enumerable: true,
+	get: function() {
+		return repositoryDoomConfigPath;
+	}
+});
+Object.defineProperty(exports, "resolvePlanningPlansDirectory", {
+	enumerable: true,
+	get: function() {
+		return resolvePlanningPlansDirectory;
+	}
+});
+
+//# sourceMappingURL=config-BUw5kHsx.cjs.map

package/dist/config-BUw5kHsx.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-BUw5kHsx.cjs","names":["fs","parseDoomConfig","os","poHomeDirectory","path","mergeDoomConfigs","parseYaml","createHash","configLeafKeys","configScopeOf","valueAtKeyPath"],"sources":["../src/services/config/index.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\nimport fs from 'node:fs';\nimport os from 'node:os';\nimport path from 'node:path';\n\nimport { poHomeDirectory } from '@agimon-ai/po-core/piSettings';\nimport { parse as parseYaml } from 'yaml';\n\nimport type {\n  ConfigDiagnostic,\n  ConfigValueOrigin,\n  DoomConfig,\n  DoomConfigLayer,\n  DoomConfigLayers,\n  LenientParseResult,\n} from '../../types/config';\nimport { configLeafKeys, configScopeOf, mergeDoomConfigs, parseDoomConfig, valueAtKeyPath } from '../configPolicy';\n\nconst DOOM_DIR = '.po';\nconst CONFIG_FILE = 'config.yaml';\nconst PLANS_DIR = 'plans';\n\nfunction readConfig(filePath: string): DoomConfig {\n  return fs.existsSync(filePath)\n    ? parseDoomConfig(fs.readFileSync(filePath, 'utf8'), filePath)\n    : { projectTrust: 'ask' };\n}\n\nasync function readConfigAsync(filePath: string): Promise<DoomConfig> {\n  try {\n    return parseDoomConfig(await fs.promises.readFile(filePath, 'utf8'), filePath);\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { projectTrust: 'ask' };\n    throw error;\n  }\n}\n\nexport function globalDoomConfigDirectory(homeDirectory = os.homedir()): string {\n  return poHomeDirectory(homeDirectory);\n}\n\nexport function globalDoomConfigPath(homeDirectory = os.homedir()): string {\n  return path.join(globalDoomConfigDirectory(homeDirectory), CONFIG_FILE);\n}\n\nexport function resolvePlanningPlansDirectory(\n  configured: string | undefined,\n  repoRoot: string,\n  homeDirectory = os.homedir(),\n): string {\n  // Under Po's home, so Po writes nothing into ~/.pi.\n  if (!configured) return path.join(globalDoomConfigDirectory(homeDirectory), PLANS_DIR);\n  if (configured === '~') return homeDirectory;\n  if (configured.startsWith('~/')) return path.resolve(homeDirectory, configured.slice(2));\n  if (configured.startsWith('~')) {\n    throw new Error(\"Doom planning plansDirectory supports only '~' or '~/' home aliases\");\n  }\n  return path.isAbsolute(configured) ? path.normalize(configured) : path.resolve(repoRoot, configured);\n}\n\nexport function repositoryDoomConfigPath(repoRoot: string): string {\n  return path.join(repoRoot, DOOM_DIR, CONFIG_FILE);\n}\n\n/**\n * True when a repository's `.po` folder is Po's home itself, as it is for a\n * session rooted at home. That folder is already the global layer; reading it\n * again as the repository layer would apply global-only keys at repository scope.\n */\nexport function isGlobalDoomConfigRoot(repoRoot: string, homeDirectory = os.homedir()): boolean {\n  return path.resolve(repoRoot, DOOM_DIR) === path.resolve(globalDoomConfigDirectory(homeDirectory));\n}\n\nfunction repositoryConfigFor(repoRoot: string, homeDirectory: string): string | undefined {\n  return isGlobalDoomConfigRoot(repoRoot, homeDirectory) ? undefined : repositoryDoomConfigPath(repoRoot);\n}\n\n/** Process-local distribution defaults never grant native authority or modify user files. */\nfunction distributionDefaults(config: DoomConfig, environment: NodeJS.ProcessEnv): DoomConfig {\n  if (environment.PO_DISTRIBUTION !== 'desktop') return config;\n  return { ...config, computerUse: { ...config.computerUse, enabled: config.computerUse?.enabled ?? true } };\n}\n\nexport function loadDoomConfig(\n  repoRoot: string,\n  homeDirectory = os.homedir(),\n  environment: NodeJS.ProcessEnv = process.env,\n): DoomConfig {\n  const repositoryPath = repositoryConfigFor(repoRoot, homeDirectory);\n  return distributionDefaults(\n    mergeDoomConfigs(\n      readConfig(globalDoomConfigPath(homeDirectory)),\n      repositoryPath === undefined ? { projectTrust: 'ask' } : readConfig(repositoryPath),\n    ),\n    environment,\n  );\n}\n\n/**\n * Loads the merged config, tolerating unknown keys in either file.\n *\n * Only `po sync` uses this. Everything that runs during a session keeps\n * `loadDoomConfig`, because a key a running extension cannot understand is\n * better reported than silently ignored; a build that refuses to start over\n * the same key is not.\n */\nexport function loadDoomConfigLenient(\n  repoRoot: string,\n  homeDirectory = os.homedir(),\n  environment: NodeJS.ProcessEnv = process.env,\n): LenientParseResult {\n  const read = (filePath: string | undefined): LenientParseResult =>\n    filePath !== undefined && fs.existsSync(filePath)\n      ? parseDoomConfig(fs.readFileSync(filePath, 'utf8'), filePath, { lenient: true })\n      : { config: { projectTrust: 'ask' }, diagnostics: [] };\n  const globalConfig = read(globalDoomConfigPath(homeDirectory));\n  const repositoryConfig = read(repositoryConfigFor(repoRoot, homeDirectory));\n  const diagnostics: ConfigDiagnostic[] = [...globalConfig.diagnostics, ...repositoryConfig.diagnostics];\n  // mergeDoomConfigs stays strict on purpose: its errors are cross-file scope\n  // violations on known keys, which is a different fault from an unknown key.\n  return {\n    config: distributionDefaults(mergeDoomConfigs(globalConfig.config, repositoryConfig.config), environment),\n    diagnostics,\n  };\n}\n\nexport async function loadDoomConfigAsync(\n  repoRoot: string,\n  homeDirectory = os.homedir(),\n  environment: NodeJS.ProcessEnv = process.env,\n): Promise<DoomConfig> {\n  const globalConfig = await readConfigAsync(globalDoomConfigPath(homeDirectory));\n  const repositoryPath = repositoryConfigFor(repoRoot, homeDirectory);\n  const repositoryConfig: DoomConfig =\n    repositoryPath === undefined ? { projectTrust: 'ask' } : await readConfigAsync(repositoryPath);\n  return distributionDefaults(mergeDoomConfigs(globalConfig, repositoryConfig), environment);\n}\n\n/**\n * Reads one config file as a layer: what it is, what it sets, and the bytes it\n * held. A file that does not exist is a layer that sets nothing, which is a\n * normal state rather than an error.\n */\nfunction readLayer(filePath: string): DoomConfigLayer {\n  let text: string;\n  try {\n    text = fs.readFileSync(filePath, 'utf8');\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {\n      return { filePath, exists: false, hash: '', keys: [] };\n    }\n    throw error;\n  }\n  // The raw document, not the parsed config: this is the one read that has to\n  // distinguish a key the file set from a key the parser defaulted.\n  const document = (parseYaml(text) ?? {}) as unknown;\n  return {\n    filePath,\n    exists: true,\n    hash: createHash('sha256').update(text, 'utf8').digest('hex'),\n    keys: configLeafKeys(document),\n  };\n}\n\n/**\n * The two config files kept apart, with the merge alongside them.\n *\n * `repoRoot` is optional because the global file is complete on its own: a\n * settings surface with no repository in view still has settings to show, and\n * demanding one would leave it with nothing to render rather than with the\n * global half.\n *\n * The origin answer respects the merge's own per-field rules rather than simply\n * preferring the repository: `editor` is read from the global side whatever the\n * repository says, and `projectTrust` from the repository side whatever the\n * global one says. Reporting a file as the source of a value the merge discards\n * is the exact confusion this exists to remove.\n */\nexport function loadDoomConfigLayers(\n  repoRoot: string | undefined,\n  homeDirectory = os.homedir(),\n  environment: NodeJS.ProcessEnv = process.env,\n): DoomConfigLayers {\n  const globalLayer = readLayer(globalDoomConfigPath(homeDirectory));\n  const repositoryPath = repoRoot === undefined ? undefined : repositoryConfigFor(repoRoot, homeDirectory);\n  const repositoryLayer =\n    repositoryPath === undefined ? { filePath: '', exists: false, hash: '', keys: [] } : readLayer(repositoryPath);\n  // With no repository there is nothing to merge, so the global file stands as\n  // the effective config on its own.\n  const effective =\n    repoRoot === undefined\n      ? distributionDefaults(\n          mergeDoomConfigs(readConfig(globalDoomConfigPath(homeDirectory)), { projectTrust: 'ask' }),\n          environment,\n        )\n      : loadDoomConfig(repoRoot, homeDirectory, environment);\n  const sets = (layer: DoomConfigLayer, keyPath: readonly string[]): boolean => {\n    const dotted = keyPath.join('.');\n    return layer.keys.some((key) => key === dotted || key.startsWith(`${dotted}.`));\n  };\n  return {\n    globalFile: globalLayer,\n    repositoryFile: repositoryLayer,\n    effective,\n    originOf(keyPath: readonly string[]): ConfigValueOrigin {\n      const scope = configScopeOf(keyPath);\n      if (scope !== 'global' && sets(repositoryLayer, keyPath)) return 'repository';\n      if (scope !== 'repository' && sets(globalLayer, keyPath)) return 'global';\n      return 'default';\n    },\n    valueAt: (keyPath: readonly string[]) => valueAtKeyPath(effective, keyPath),\n  };\n}\n"],"mappings":"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"}