pixelkiln 0.2.0 → 0.3.0

package/dist/index.js

@@ -409,11 +409,11 @@ var PixelLabClient = class {
    * common than the failure mode of retrying (a duplicate object), and a
    * duplicate is visible and free to delete whereas a silent gap is neither.
    */
-  async request(path15, init, attempt = 0) {
+  async request(path17, init, attempt = 0) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
     let res;
     try {
-      res = await fetch(`${BASE}${path15}`, {
+      res = await fetch(`${BASE}${path17}`, {
         ...init,
         signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
         headers: {
@@ -425,24 +425,24 @@ var PixelLabClient = class {
     } catch (err) {
       if (attempt < MAX_RETRIES) {
         await sleep(backoffMs(attempt));
-        return this.request(path15, init, attempt + 1);
+        return this.request(path17, init, attempt + 1);
       }
       throw err;
     }
     if (!res.ok && shouldRetry(res.status) && attempt < MAX_RETRIES) {
       const waitMs = retryAfterMs(res.headers.get("retry-after")) ?? backoffMs(attempt);
       await sleep(waitMs);
-      return this.request(path15, init, attempt + 1);
+      return this.request(path17, init, attempt + 1);
     }
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path15} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path17} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path15} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path17} returned invalid JSON`);
     }
   }
   async balance() {
@@ -1460,8 +1460,8 @@ import { readFile } from "fs/promises";
 function sha256(data) {
   return createHash2("sha256").update(data).digest("hex");
 }
-async function sha256File(path15) {
-  return sha256(await readFile(path15));
+async function sha256File(path17) {
+  return sha256(await readFile(path17));
 }
 function specHash(spec, styleImageHashes) {
   return sha256(
@@ -2705,10 +2705,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path15) {
-  if (!existsSync6(path15)) return { version: 1, hashes: {} };
+async function loadCache(path17) {
+  if (!existsSync6(path17)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile6(path15, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile6(path17, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -2720,18 +2720,18 @@ async function loadCache(path15) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path15, cache) {
+async function saveCache(path17, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await mkdir3(pathModule.dirname(pathModule.resolve(path15)), { recursive: true });
-  const tmp = `${path15}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir3(pathModule.dirname(pathModule.resolve(path17)), { recursive: true });
+  const tmp = `${path17}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile3(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename3(tmp, path15);
+    await rename3(tmp, path17);
   } finally {
     await rm3(tmp, { force: true });
   }
@@ -4464,6 +4464,7 @@ function mode(values) {
 // src/pipeline/salvage.ts
 import { readFile as readFile11 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
+import path14 from "path";
 async function loadClaims(lockPaths) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
@@ -4516,6 +4517,26 @@ function matchOrphanStyle(prompt, manifest) {
   if (styleIds.length <= 1) return styleIds[0] ?? null;
   return matchStyleByPattern(prompt, manifest);
 }
+async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
+  const own = path14.resolve(ownManifestPath);
+  const siblingManifestPaths = [
+    .../* @__PURE__ */ new Set([
+      ...workspaceManifestPaths,
+      ...claimPaths.map((c) => path14.join(path14.dirname(path14.resolve(c)), "pixelkiln.manifest.json"))
+    ])
+  ];
+  const siblings = [];
+  for (const siblingManifestPath of siblingManifestPaths) {
+    if (path14.resolve(siblingManifestPath) === own) continue;
+    if (!existsSync12(siblingManifestPath)) continue;
+    try {
+      const { manifest } = await loadManifest(siblingManifestPath);
+      siblings.push({ label: path14.basename(path14.dirname(siblingManifestPath)), manifest });
+    } catch {
+    }
+  }
+  return siblings;
+}
 function groupOrphansByStyle(orphans, manifest, siblings = []) {
   const matched = /* @__PURE__ */ new Map();
   const elsewhere = /* @__PURE__ */ new Map();
@@ -4627,7 +4648,7 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 
 // src/pick/salvage-server.ts
 import { mkdir as mkdir5, writeFile as writeFile7, readFile as readFile12 } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml2 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -4792,7 +4813,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path14.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path15.relative(process.cwd(), ctx.importDir) || "."
   });
   const byId = new Map(orphans.map((o) => [o.id, o]));
   const existingTags = new Map(orphans.map((o) => [o.id, o.tags]));
@@ -4821,9 +4842,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE3)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = path14.join("_salvaged", `${assetId}.png`);
-            const outFile = path14.resolve(ctx.importDir, rel);
-            await mkdir5(path14.dirname(outFile), { recursive: true });
+            const rel = path15.join("_salvaged", `${assetId}.png`);
+            const outFile = path15.resolve(ctx.importDir, rel);
+            await mkdir5(path15.dirname(outFile), { recursive: true });
             await writeFile7(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
@@ -4850,7 +4871,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               error: null,
               sourceUrl: orphan.previewUrl,
               outputs: [{
-                path: portableOutputPath(outFile, path14.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path15.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -4882,6 +4903,233 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
     }
   });
 }
+
+// src/workspace.ts
+import { mkdir as mkdir6, readFile as readFile13, rename as rename5, rm as rm6, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import path16 from "path";
+import { z as z4 } from "zod";
+var WorkspaceProjectSchema = z4.object({
+  id: z4.string().min(1),
+  /** Manifest path, relative to the catalog file's own directory. */
+  manifest: z4.string().min(1),
+  /** Lockfile path, relative to the catalog file's own directory. */
+  lock: z4.string().min(1),
+  provider: z4.string().min(1).default("pixellab"),
+  /** Free-form label for a shared account, e.g. distinguishing sandboxes. */
+  account: z4.string().optional()
+}).strict();
+var WorkspaceSchema = z4.object({
+  version: z4.literal(1),
+  projects: z4.array(WorkspaceProjectSchema).default([])
+}).strict();
+function parseWorkspace(raw) {
+  const parsed = WorkspaceSchema.safeParse(raw);
+  if (parsed.success) return parsed.data;
+  throw new Error(
+    `Workspace catalog is not valid v1:
+${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
+  );
+}
+async function loadWorkspace(workspacePath) {
+  if (!existsSync13(workspacePath)) return { version: 1, projects: [] };
+  let raw;
+  try {
+    raw = JSON.parse(await readFile13(workspacePath, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `Workspace catalog at ${workspacePath} is malformed:
+${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return parseWorkspace(raw);
+}
+async function saveWorkspace(workspacePath, ws) {
+  const sorted = {
+    version: 1,
+    projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
+  };
+  await mkdir6(path16.dirname(path16.resolve(workspacePath)), { recursive: true });
+  const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await writeFile8(tmp, JSON.stringify(sorted, null, 2) + "\n");
+    await rename5(tmp, workspacePath);
+  } finally {
+    await rm6(tmp, { force: true });
+  }
+}
+function toPortablePath(dir, absolute) {
+  return path16.relative(dir, absolute).split(path16.sep).join("/");
+}
+function resolveProject(dir, project) {
+  return {
+    manifestPath: path16.resolve(dir, project.manifest.split("/").join(path16.sep)),
+    lockPath: path16.resolve(dir, project.lock.split("/").join(path16.sep))
+  };
+}
+function validateWorkspace(ws, dir) {
+  const diagnostics = [];
+  const idCounts = /* @__PURE__ */ new Map();
+  const lockOwners = /* @__PURE__ */ new Map();
+  const manifestOwners = /* @__PURE__ */ new Map();
+  for (const project of ws.projects) {
+    idCounts.set(project.id, (idCounts.get(project.id) ?? 0) + 1);
+    const { manifestPath, lockPath } = resolveProject(dir, project);
+    lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
+    manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
+    if (path16.isAbsolute(project.manifest) || path16.isAbsolute(project.lock)) {
+      diagnostics.push({
+        id: "absolute-path",
+        level: "warning",
+        message: `project "${project.id}" stores an absolute path \u2014 the catalog will not resolve correctly if this tree is cloned or moved elsewhere`
+      });
+    }
+    if (!existsSync13(manifestPath)) {
+      diagnostics.push({
+        id: "missing-manifest",
+        level: "error",
+        message: `project "${project.id}" manifest not found: ${manifestPath}`
+      });
+    }
+    if (!existsSync13(lockPath)) {
+      diagnostics.push({
+        id: "missing-lock",
+        level: "error",
+        message: `project "${project.id}" lockfile not found: ${lockPath}`
+      });
+    }
+  }
+  for (const [id, count] of idCounts) {
+    if (count > 1) {
+      diagnostics.push({
+        id: "duplicate-id",
+        level: "error",
+        message: `project id "${id}" is registered ${count} times`
+      });
+    }
+  }
+  for (const [lockPath, ids] of lockOwners) {
+    if (ids.length > 1) {
+      diagnostics.push({
+        id: "duplicate-lock",
+        level: "error",
+        message: `${ids.join(", ")} all register the same lockfile: ${lockPath}`
+      });
+    }
+  }
+  for (const [manifestPath, ids] of manifestOwners) {
+    if (ids.length > 1) {
+      diagnostics.push({
+        id: "duplicate-manifest",
+        level: "warning",
+        message: `${ids.join(", ")} share manifest ${manifestPath} \u2014 expected only when they are variant lockfiles beside one manifest`
+      });
+    }
+  }
+  const providers = new Set(ws.projects.map((p) => p.provider));
+  if (providers.size > 1) {
+    diagnostics.push({
+      id: "mixed-provider",
+      level: "warning",
+      message: `registered projects use different providers: ${[...providers].sort().join(", ")} \u2014 spend totals are kept separate per unit, but confirm this is intentional`
+    });
+  }
+  return diagnostics;
+}
+
+// src/pipeline/workspace.ts
+async function workspaceClaims(ws, dir) {
+  const lockPaths = [];
+  const byProject = {};
+  const claimed = /* @__PURE__ */ new Set();
+  for (const project of ws.projects) {
+    const { lockPath } = resolveProject(dir, project);
+    lockPaths.push(lockPath);
+    let projectClaims;
+    try {
+      projectClaims = await loadClaims([lockPath]);
+    } catch (err) {
+      throw new Error(
+        `Project "${project.id}" lockfile is unreadable: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    byProject[project.id] = projectClaims.size;
+    for (const id of projectClaims) claimed.add(id);
+  }
+  return { claimed, byProject, lockPaths };
+}
+function emptyStateCounts() {
+  return {
+    ok: 0,
+    missing: 0,
+    untracked: 0,
+    stale: 0,
+    orphaned: 0,
+    "in-flight": 0,
+    recoverable: 0,
+    failed: 0
+  };
+}
+async function workspaceStatus(ws, dir) {
+  const diagnostics = validateWorkspace(ws, dir);
+  const provider = PixelLabProvider.forOffline();
+  const projects = [];
+  const totalsByState = emptyStateCounts();
+  const totalsSpend = { generations: 0, usd: 0, free: 0 };
+  for (const project of ws.projects) {
+    const { manifestPath, lockPath } = resolveProject(dir, project);
+    const base = {
+      id: project.id,
+      provider: project.provider,
+      account: project.account ?? null,
+      manifest: manifestPath,
+      lock: lockPath
+    };
+    try {
+      const loaded = await loadManifest(manifestPath);
+      const specs = await resolveSpecs(loaded, { provider });
+      const lock = await loadLock(lockPath);
+      normalizeLockOutputPaths(lock, specs);
+      const plan = await buildPlan(specs, lock);
+      const byState = summarize(plan);
+      const spend = spendByUnit(lock);
+      for (const state of Object.keys(byState)) {
+        totalsByState[state] += byState[state];
+      }
+      for (const unit of Object.keys(spend)) {
+        totalsSpend[unit] += spend[unit];
+      }
+      projects.push({
+        ...base,
+        entries: Object.keys(lock.entries).length,
+        byState,
+        spendByUnit: spend,
+        error: null
+      });
+    } catch (err) {
+      projects.push({
+        ...base,
+        entries: 0,
+        byState: emptyStateCounts(),
+        spendByUnit: { generations: 0, usd: 0, free: 0 },
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  let claims = 0;
+  try {
+    claims = (await workspaceClaims(ws, dir)).claimed.size;
+  } catch {
+  }
+  return {
+    version: 1,
+    safe: !diagnostics.some((d) => d.level === "error") && projects.every((p) => !p.error),
+    dir,
+    projects,
+    totals: { byState: totalsByState, spendByUnit: totalsSpend, claims },
+    diagnostics
+  };
+}
 export {
   AssetSchema,
   DEFAULT_RATE_LIMIT,
@@ -4898,6 +5146,8 @@ export {
   PixelLabProvider,
   StyleSchema,
   UnsupportedCapabilityError,
+  WorkspaceProjectSchema,
+  WorkspaceSchema,
   adopt,
   applyTags,
   auditStyle,
@@ -4928,6 +5178,8 @@ export {
   loadClaims,
   loadLock,
   loadManifest,
+  loadSiblingManifests,
+  loadWorkspace,
   lockKey,
   matchOrphanStyle,
   measureBalanceChange,
@@ -4942,6 +5194,7 @@ export {
   packStyle,
   paletteDistance,
   parseLock,
+  parseWorkspace,
   pngSize,
   poll,
   portableOutputPath,
@@ -4955,6 +5208,7 @@ export {
   resolveEntryOutputs,
   resolveOutputPath,
   resolvePackInputs,
+  resolveProject,
   resolveSpecEntryOutputs,
   resolveSpecOutputs,
   resolveSpecs,
@@ -4964,6 +5218,7 @@ export {
   runPicker,
   runSalvage,
   saveLock,
+  saveWorkspace,
   scanAssets,
   selectEntryOutput,
   sha256,
@@ -4979,11 +5234,15 @@ export {
   tileFeatureOutputCount,
   tileVariationCount,
   tilesCost,
+  toPortablePath,
   totalSpend,
   upsert,
   validateCostEstimate,
+  validateWorkspace,
   verifyArtifactBundle,
   withArtifactManifest,
+  workspaceClaims,
+  workspaceStatus,
   writeArtifactBundle,
   writeManagedArtifactBundle
 };