@qlingzzy/qling 1.1.1 → 1.2.1

package/scripts/build-portable-win.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * Build a Windows portable zip that embeds a Node.js runtime (no system Node required).
+ * Usage: node scripts/build-portable-win.mjs [--skip-node]
+ *
+ * Output: dist-portable/qling-win-x64.zip
+ * Layout:
+ *   qling-win-x64/
+ *     runtime/node.exe   # bundled Node (same major as build host by default)
+ *     package/           # npm pack contents
+ *     qling.cmd          # launcher → runtime\node.exe package\dist\index.js
+ *     README.txt
+ */
+import { spawnSync, execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  mkdir,
+  rm,
+  readFile,
+  writeFile,
+  copyFile,
+  access,
+} from "node:fs/promises";
+import { createWriteStream, existsSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pipeline } from "node:stream/promises";
+import { get } from "node:https";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..");
+const OUT_DIR = join(ROOT, "dist-portable");
+const STAGE = join(OUT_DIR, "qling-win-x64");
+const ZIP_PATH = join(OUT_DIR, "qling-win-x64.zip");
+const skipNode = process.argv.includes("--skip-node");
+
+const pkg = JSON.parse(await readFile(join(ROOT, "package.json"), "utf8"));
+const version = pkg.version;
+const nodeVersion = process.version; // e.g. v22.22.1
+const nodeDistName = `node-${nodeVersion}-win-x64`;
+const nodeZipUrl = `https://nodejs.org/dist/${nodeVersion}/${nodeDistName}.zip`;
+
+console.log(`[portable] building qling ${version} for win-x64…`);
+console.log(`[portable] host node ${nodeVersion} ${process.arch}`);
+
+await rm(OUT_DIR, { recursive: true, force: true });
+await mkdir(STAGE, { recursive: true });
+
+// 1) npm pack current tree
+const pack = spawnSync(
+  process.platform === "win32" ? "npm.cmd" : "npm",
+  ["pack", "--pack-destination", OUT_DIR],
+  { cwd: ROOT, encoding: "utf8", shell: true }
+);
+if (pack.status !== 0) {
+  console.error(pack.stdout, pack.stderr);
+  process.exit(1);
+}
+const tgzName = (pack.stdout || "")
+  .trim()
+  .split(/\r?\n/)
+  .filter(Boolean)
+  .pop();
+if (!tgzName) {
+  console.error("npm pack produced no tarball name");
+  process.exit(1);
+}
+const tgzPath = join(OUT_DIR, tgzName);
+console.log(`[portable] packed ${tgzName}`);
+
+try {
+  execFileSync("tar", ["-xzf", tgzPath, "-C", STAGE], { stdio: "inherit" });
+} catch (err) {
+  console.error("tar extract failed:", err instanceof Error ? err.message : err);
+  process.exit(1);
+}
+
+// 2) Bundle Node runtime
+const runtimeDir = join(STAGE, "runtime");
+await mkdir(runtimeDir, { recursive: true });
+let bundledNode = false;
+let nodeNote = "System Node.js >= 18 on PATH";
+
+if (!skipNode && process.platform === "win32") {
+  const cacheDir = join(OUT_DIR, ".node-cache");
+  await mkdir(cacheDir, { recursive: true });
+  const nodeZipPath = join(cacheDir, `${nodeDistName}.zip`);
+  if (!existsSync(nodeZipPath)) {
+    console.log(`[portable] downloading ${nodeZipUrl}`);
+    await downloadFile(nodeZipUrl, nodeZipPath);
+  } else {
+    console.log(`[portable] using cached ${nodeZipPath}`);
+  }
+  const extractDir = join(cacheDir, nodeDistName);
+  await rm(extractDir, { recursive: true, force: true });
+  execFileSync("tar", ["-xf", nodeZipPath, "-C", cacheDir], { stdio: "inherit" });
+  const nodeExeSrc = join(extractDir, "node.exe");
+  await access(nodeExeSrc);
+  await copyFile(nodeExeSrc, join(runtimeDir, "node.exe"));
+  // LICENSE if present
+  const license = join(extractDir, "LICENSE");
+  if (existsSync(license)) {
+    await copyFile(license, join(runtimeDir, "NODE-LICENSE"));
+  }
+  bundledNode = true;
+  nodeNote = `Bundled Node ${nodeVersion} (runtime\\node.exe)`;
+  console.log(`[portable] bundled node.exe from ${nodeDistName}`);
+} else if (!skipNode) {
+  console.warn("[portable] non-Windows host: skip embedding node.exe (use --skip-node to silence)");
+}
+
+const launcher = `@echo off
+setlocal
+set "ROOT=%~dp0"
+set "NODE_EXE="
+if exist "%ROOT%runtime\\node.exe" set "NODE_EXE=%ROOT%runtime\\node.exe"
+if not defined NODE_EXE (
+  where node >nul 2>nul && set "NODE_EXE=node"
+)
+if not defined NODE_EXE (
+  echo [qling] No bundled runtime and no system Node on PATH.
+  echo [qling] Re-download the portable zip or install Node.js ^>= 18.
+  exit /b 1
+)
+"%NODE_EXE%" "%ROOT%package\\dist\\index.js" %*
+`;
+await writeFile(join(STAGE, "qling.cmd"), launcher, "utf8");
+
+const readme = `Qling ${version} — Windows portable layout
+========================================
+
+${bundledNode ? "This build embeds a Node.js runtime — no system Node install required." : "This build expects system Node.js >= 18 on PATH."}
+
+Runtime:
+  ${nodeNote}
+
+Run:
+  .\\qling.cmd --version
+  .\\qling.cmd doctor
+  .\\qling.cmd setup
+
+Notes:
+  - better-sqlite3 native binary is compiled for the Node ABI used at pack time.
+  - Prefer matching the bundled Node major version if you replace runtime\\node.exe.
+
+npm alternative:
+  npm install -g @qlingzzy/qling@${version} --registry https://registry.npmjs.org/
+
+Source: https://github.com/Zzy-min/qling
+`;
+await writeFile(join(STAGE, "README.txt"), readme, "utf8");
+
+await rm(ZIP_PATH, { force: true });
+execFileSync("tar", ["-a", "-cf", ZIP_PATH, "-C", OUT_DIR, "qling-win-x64"], {
+  stdio: "inherit",
+});
+
+const buf = await readFile(ZIP_PATH);
+const sha256 = createHash("sha256").update(buf).digest("hex");
+const meta = {
+  version,
+  zip: "qling-win-x64.zip",
+  path: ZIP_PATH,
+  size: buf.length,
+  sha256,
+  bundledNode,
+  nodeVersion: bundledNode ? nodeVersion : null,
+  createdAt: new Date().toISOString(),
+};
+await writeFile(join(OUT_DIR, "portable-meta.json"), JSON.stringify(meta, null, 2) + "\n");
+
+console.log(`[portable] wrote ${ZIP_PATH}`);
+console.log(`[portable] size=${buf.length} sha256=${sha256}`);
+console.log(`[portable] bundledNode=${bundledNode}`);
+console.log(`[portable] meta: dist-portable/portable-meta.json`);
+
+function downloadFile(url, dest) {
+  return new Promise((resolvePromise, reject) => {
+    const file = createWriteStream(dest);
+    get(url, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        file.close();
+        downloadFile(res.headers.location, dest).then(resolvePromise, reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`download failed: HTTP ${res.statusCode}`));
+        return;
+      }
+      pipeline(res, file).then(resolvePromise, reject);
+    }).on("error", reject);
+  });
+}

package/scripts/dep-layers.mjs

@@ -68,6 +68,9 @@ export function layerOf(rel) {
     p === "agent-loop.ts" ||
     p.startsWith("agent/") ||
     p.startsWith("tools/") ||
+    p.startsWith("execution/") ||
+    p === "slash-context.ts" ||
+    p === "slash-ports.ts" ||
     p === "repl.ts"
   ) {
     return "agent-runtime";
@@ -76,6 +79,7 @@ export function layerOf(rel) {
     p === "sdk.ts" ||
     p === "daemon.ts" ||
     p === "dashboard-server.ts" ||
+    p.startsWith("dashboard/") ||
     p.endsWith("-report.ts") ||
     p === "doctor.ts" ||
     p === "statusline.ts" ||
@@ -228,7 +232,14 @@ function formatMermaid(layerCounts, edges) {
 
 const asJson = process.argv.includes("--json");
 const strict = process.argv.includes("--strict");
+const baselineMode = process.argv.includes("--baseline");
+const writeBaseline = process.argv.includes("--write-baseline");
 const writeDoc = process.argv.includes("--write-doc");
+const BASELINE_PATH = join(ROOT, "docs", "dependency-layers.baseline.json");
+
+function edgeKey(f) {
+  return `${f.fromLayer}->${f.toLayer}::${f.from}::${f.to}`;
+}
 
 const result = await scanLayers();
 
@@ -270,6 +281,45 @@ if (writeDoc) {
   console.error(`[dep-layers] wrote ${snap}`);
 }
 
+if (writeBaseline) {
+  await mkdir(dirname(BASELINE_PATH), { recursive: true });
+  const keys = result.forbidden.map(edgeKey).sort();
+  await writeFile(
+    BASELINE_PATH,
+    JSON.stringify(
+      {
+        generatedAt: new Date().toISOString(),
+        note: "Known reverse-layer edges. --baseline fails only on NEW keys not listed here.",
+        forbiddenCount: keys.length,
+        forbidden: keys,
+      },
+      null,
+      2
+    ) + "\n",
+    "utf8"
+  );
+  console.error(`[dep-layers] wrote baseline ${BASELINE_PATH} (${keys.length} edges)`);
+}
+
+if (baselineMode) {
+  let known = new Set();
+  if (existsSync(BASELINE_PATH)) {
+    const raw = JSON.parse(await readFile(BASELINE_PATH, "utf8"));
+    known = new Set(raw.forbidden || []);
+  }
+  const novel = result.forbidden.filter((f) => !known.has(edgeKey(f)));
+  console.log(
+    `baseline gate: known=${known.size} current=${result.forbiddenCount} novel=${novel.length}`
+  );
+  if (novel.length > 0) {
+    console.error("NEW forbidden edges (not in baseline):");
+    for (const f of novel) {
+      console.error(`  ${f.fromLayer} -> ${f.toLayer}: ${f.from} imports ${f.to}`);
+    }
+    process.exit(1);
+  }
+}
+
 if (strict && result.forbiddenCount > 0) {
   process.exit(1);
 }

package/scripts/sync-scoop-bucket.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/** Copy packaging/scoop/qling.json → packaging/scoop-bucket/qling.json */
+import { copyFile, readFile } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const src = join(root, "packaging", "scoop", "qling.json");
+const dest = join(root, "packaging", "scoop-bucket", "qling.json");
+await copyFile(src, dest);
+const j = JSON.parse(await readFile(dest, "utf8"));
+console.log(`sync-scoop-bucket OK → v${j.version} hash=${j.hash?.slice(0, 20)}…`);

package/scripts/sync-winget-sha.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * Fill winget InstallerSha256 from dist-portable/portable-meta.json
+ */
+import { readFile, writeFile, readdir } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const metaPath = join(root, "dist-portable", "portable-meta.json");
+if (!existsSync(metaPath)) {
+  console.error("missing dist-portable/portable-meta.json — run npm run build:portable-win first");
+  process.exit(1);
+}
+const meta = JSON.parse(await readFile(metaPath, "utf8"));
+const sha = String(meta.sha256 || "").toLowerCase();
+if (!/^[a-f0-9]{64}$/.test(sha)) {
+  console.error("invalid sha256 in portable-meta.json");
+  process.exit(1);
+}
+
+const version = meta.version || JSON.parse(await readFile(join(root, "package.json"), "utf8")).version;
+const targets = [
+  join(root, "packaging", "winget", "Zzy-min.qling.yaml"),
+  join(root, "packaging", "winget", "manifests", "Zzy-min", "qling", version, "Zzy-min.qling.installer.yaml"),
+];
+
+for (const file of targets) {
+  if (!existsSync(file)) {
+    console.warn("skip missing", file);
+    continue;
+  }
+  let text = await readFile(file, "utf8");
+  text = text.replace(/InstallerSha256:\s*[A-Za-z0-9_]+/g, `InstallerSha256: ${sha}`);
+  text = text.replace(/PackageVersion:\s*[\d.]+/g, `PackageVersion: ${version}`);
+  text = text.replace(/v[\d.]+\//g, `v${version}/`);
+  await writeFile(file, text, "utf8");
+  console.log("updated", file);
+}
+
+// Scoop: rewrite Extras-compatible 64bit manifest
+const { spawnSync } = await import("node:child_process");
+const scoopScript = join(root, "scripts", "write-scoop-manifest.mjs");
+const r = spawnSync(process.execPath, [scoopScript], { cwd: root, encoding: "utf8" });
+process.stdout.write(r.stdout || "");
+process.stderr.write(r.stderr || "");
+if (r.status !== 0) process.exit(r.status || 1);
+
+// Multi-file winget for this version dir (create if missing)
+const multiDir = join(root, "packaging", "winget", "manifests", "Zzy-min", "qling", version);
+if (!existsSync(multiDir)) {
+  console.warn("note: multi-file winget dir missing for", version, "- create under packaging/winget/manifests");
+}
+
+console.log(`sync-winget-sha OK version=${version} sha=${sha.slice(0, 16)}… bundledNode=${meta.bundledNode}`);

package/scripts/validate-packaging.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 /**
- * Validate Scoop / winget draft manifests align with package.json version.
+ * Validate Scoop / winget manifests align with package.json version.
  * Usage: node scripts/validate-packaging.mjs
  */
 import { readFile } from "node:fs/promises";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
 
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
 const errors = [];
@@ -18,17 +19,26 @@ const scoop = JSON.parse(scoopRaw);
 if (scoop.version !== version) {
   errors.push(`scoop version ${scoop.version} != package ${version}`);
 }
-if (!String(scoop.url || "").includes(version)) {
-  errors.push(`scoop url does not pin ${version}: ${scoop.url}`);
+const scoopUrl =
+  scoop.architecture?.["64bit"]?.url || scoop.url || "";
+const scoopHash =
+  scoop.architecture?.["64bit"]?.hash || scoop.hash || "";
+if (!String(scoopUrl).includes(version)) {
+  errors.push(`scoop url does not pin ${version}: ${scoopUrl}`);
 }
-if (!Array.isArray(scoop.notes) || !scoop.notes.some((n) => /DRAFT|draft/i.test(n))) {
-  errors.push("scoop notes should mark DRAFT status");
+if (!scoop.architecture?.["64bit"]) {
+  errors.push("scoop should nest url/hash under architecture.64bit (Extras style)");
 }
-const hash = String(scoop.hash || "");
-if (!hash || /TODO|REPLACE/i.test(hash)) {
-  errors.push("scoop hash still placeholder — fill real SHA256 after npm publish");
-} else if (!/^(sha256:)?[a-f0-9]{64}$/i.test(hash)) {
-  errors.push(`scoop hash looks invalid: ${hash}`);
+if (!scoopHash || /TODO|REPLACE|PLACEHOLDER/i.test(String(scoopHash))) {
+  errors.push("scoop hash still placeholder — run build:portable-win + sync-winget-sha");
+} else if (!/^(sha256:)?[a-f0-9]{64}$/i.test(String(scoopHash))) {
+  errors.push(`scoop hash looks invalid: ${scoopHash}`);
+}
+if (/sha256:/i.test(String(scoopHash))) {
+  errors.push("scoop hash should be plain hex (no sha256: prefix) for Extras");
+}
+if (!String(scoop.bin || "").includes("qling")) {
+  errors.push("scoop bin should expose qling");
 }
 
 const winget = await readFile(
@@ -41,8 +51,36 @@ if (!winget.includes(`PackageVersion: ${version}`)) {
 if (!winget.includes("PackageIdentifier: Zzy-min.qling")) {
   errors.push("winget PackageIdentifier missing");
 }
-if (!/DRAFT|not submitted/i.test(winget)) {
-  errors.push("winget should remain marked as DRAFT");
+if (/InstallerSha256:\s*(0{64}|PLACEHOLDER)/i.test(winget)) {
+  errors.push("winget InstallerSha256 is still placeholder");
+}
+
+const multiInstaller = join(
+  root,
+  "packaging",
+  "winget",
+  "manifests",
+  "Zzy-min",
+  "qling",
+  version,
+  "Zzy-min.qling.installer.yaml"
+);
+if (existsSync(multiInstaller)) {
+  const mi = await readFile(multiInstaller, "utf8");
+  if (/InstallerSha256:\s*(0{64}|PLACEHOLDER)/i.test(mi)) {
+    errors.push("multi-file winget installer sha still placeholder");
+  }
+  if (!mi.includes(`PackageVersion: ${version}`)) {
+    errors.push("multi-file winget installer version mismatch");
+  }
+}
+
+const bucket = join(root, "packaging", "scoop-bucket", "qling.json");
+if (existsSync(bucket)) {
+  const b = JSON.parse(await readFile(bucket, "utf8"));
+  if (b.version !== version) errors.push("scoop-bucket version mismatch");
+  const bHash = b.architecture?.["64bit"]?.hash || b.hash;
+  if (bHash !== scoopHash) errors.push("scoop-bucket hash out of sync with scoop/qling.json");
 }
 
 if (errors.length) {
@@ -52,6 +90,6 @@ if (errors.length) {
 }
 
 console.log(`validate-packaging OK (version ${version})`);
-console.log("  scoop:", scoop.url);
+console.log("  scoop:", scoopUrl);
+console.log("  scoop.hash:", String(scoopHash).slice(0, 20) + "…");
 console.log("  winget: Zzy-min.qling @", version);
-console.log("  note: still drafts — not published to official catalogs");

package/scripts/write-scoop-manifest.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Write Scoop-compatible manifest (Extras style):
+ * - 4-space indent
+ * - plain SHA256 (no sha256: prefix)
+ * - architecture.64bit for url/hash/extract_dir
+ * - autoupdate.architecture.64bit
+ *
+ * Reads dist-portable/portable-meta.json when present.
+ */
+import { readFile, writeFile } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+const version = pkg.version;
+
+let hash = "PLACEHOLDER";
+const metaPath = join(root, "dist-portable", "portable-meta.json");
+if (existsSync(metaPath)) {
+  const meta = JSON.parse(await readFile(metaPath, "utf8"));
+  hash = String(meta.sha256 || "").toLowerCase();
+}
+
+const manifest = {
+  version,
+  description: "Local-first Chinese AI Agent CLI workbench (Qling / 轻灵).",
+  homepage: "https://github.com/Zzy-min/qling",
+  license: "MIT",
+  notes: [
+    "Portable zip embeds a Node.js runtime (no system Node required).",
+    "Set API keys as user environment variables (never commit secrets).",
+    "After install: run qling doctor, then qling setup.",
+  ],
+  architecture: {
+    "64bit": {
+      url: `https://github.com/Zzy-min/qling/releases/download/v${version}/qling-win-x64.zip`,
+      hash,
+      extract_dir: "qling-win-x64",
+    },
+  },
+  bin: "qling.cmd",
+  post_install: [
+    "Write-Host 'Run qling doctor, then qling setup.' -ForegroundColor Cyan",
+  ],
+  checkver: {
+    github: "https://github.com/Zzy-min/qling",
+  },
+  autoupdate: {
+    architecture: {
+      "64bit": {
+        url: "https://github.com/Zzy-min/qling/releases/download/v$version/qling-win-x64.zip",
+      },
+    },
+  },
+};
+
+const json = JSON.stringify(manifest, null, 4) + "\n";
+const targets = [
+  join(root, "packaging", "scoop", "qling.json"),
+  join(root, "packaging", "scoop-bucket", "qling.json"),
+];
+for (const t of targets) {
+  await writeFile(t, json, "utf8");
+  console.log("wrote", t);
+}
+console.log(`version=${version} hash=${hash.slice(0, 16)}…`);

package/dist/session/durable-session-supervisor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"durable-session-supervisor.d.ts","sourceRoot":"","sources":["../../src/session/durable-session-supervisor.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA4B;IAChD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqB;IACrD,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,+BAA+B;IAMpD,KAAK,IAAI,IAAI;IAQP,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAOb,IAAI;YAyBJ,iBAAiB;YAcjB,iBAAiB;YAiBjB,sBAAsB;YAiCtB,cAAc;YAoCd,iBAAiB;YAyBjB,WAAW;CA8B1B"}