hanoman 0.1.42 → 0.1.44

package/dist/server.js

@@ -6092,6 +6092,9 @@ var init_api = __esm({
       ideCompare: (id, from, to) => `${API}/projects/${id}/compare?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`,
       ideCompareFile: (id, from, to, path2) => `${API}/projects/${id}/compare/file?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}&path=${encodeURIComponent(path2)}`,
       ideGit: (id) => `${API}/projects/${id}/git`,
+      // ADR-0121 · operasi berkas Explorer: satu path untuk buat/rename/hapus, satu untuk unggah.
+      ideEntry: (id, path2) => `${API}/projects/${id}/entry${path2 ? `?path=${encodeURIComponent(path2)}` : ""}`,
+      ideUpload: (id) => `${API}/projects/${id}/upload`,
       ideGitMerge: (id) => `${API}/projects/${id}/git/merge`,
       // SPEC-229 · merge git graph isolasi
       // SPEC-234 · status working tree (staged/unstaged) + diff satu file working tree
@@ -6119,6 +6122,9 @@ var init_api = __esm({
       sessionReviewFile: (id, path2) => `${API}/terminal/sessions/${id}/review/${path2}`,
       sessionIntegrate: (id) => `${API}/terminal/sessions/${id}/integrate`,
       terminalWs: (id) => `${API}/terminal/sessions/${id}/ws`,
+      // SPEC-816 · lampiran gambar sesi (multipart). Di bawah prefix /terminal supaya ikut capability
+      // `sessions` yang sudah ada — POST menurunkan cabang tulisnya tanpa perubahan peta.
+      terminalAttachments: (id) => `${API}/terminal/sessions/${id}/attachments`,
       // SPEC-362 · ADR-0079 · riwayat sesi. Di bawah prefix /terminal supaya ikut capability
       // `sessions` yang sudah ada (services/agent-capabilities.ts) tanpa menambah domain baru.
       sessionHistory: (qs = "") => `${API}/terminal/history${qs}`,
@@ -6263,11 +6269,11 @@ function isExternalLink(target2) {
   return !target2 || /^(https?:|#|mailto:)/.test(target2);
 }
 function resolveLink(fromRel, target2) {
-  const clean = target2.trim().split(/\s+/)[0].split("#")[0].split("\\").join("/");
-  if (!clean) return "";
-  if (clean.startsWith("/")) return clean.slice(1).split("/").filter((p) => p && p !== ".").join("/");
+  const clean2 = target2.trim().split(/\s+/)[0].split("#")[0].split("\\").join("/");
+  if (!clean2) return "";
+  if (clean2.startsWith("/")) return clean2.slice(1).split("/").filter((p) => p && p !== ".").join("/");
   const dir2 = fromRel.includes("/") ? fromRel.slice(0, fromRel.lastIndexOf("/")) : "";
-  const parts = (dir2 ? dir2.split("/") : []).concat(clean.replace(/^\.\//, "").split("/"));
+  const parts = (dir2 ? dir2.split("/") : []).concat(clean2.replace(/^\.\//, "").split("/"));
   const out3 = [];
   for (const p of parts) {
     if (p === "" || p === ".") continue;
@@ -9362,6 +9368,400 @@ var init_session_id = __esm({
   }
 });
 
+// src/services/secret-box.ts
+import { chmodSync as chmodSync2, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync } from "node:fs";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { dirname as dirname6, join as join4 } from "node:path";
+function isEncrypted(value) {
+  return value.startsWith(ENC_PREFIX);
+}
+function encryptWithKey(plain, key) {
+  const iv = randomBytes(IV_BYTES);
+  const cipher = createCipheriv(ALGO, key, iv);
+  const body = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+  const tag2 = cipher.getAuthTag();
+  return `${ENC_PREFIX}${iv.toString("base64url")}:${tag2.toString("base64url")}:${body.toString("base64url")}`;
+}
+function decryptWithKey(value, key) {
+  if (!isEncrypted(value)) return value;
+  const parts = value.slice(ENC_PREFIX.length).split(":");
+  if (parts.length !== 3) return null;
+  const [ivRaw, tagRaw, bodyRaw] = parts;
+  try {
+    const decipher = createDecipheriv(ALGO, key, Buffer.from(ivRaw, "base64url"));
+    decipher.setAuthTag(Buffer.from(tagRaw, "base64url"));
+    return Buffer.concat([decipher.update(Buffer.from(bodyRaw, "base64url")), decipher.final()]).toString("utf8");
+  } catch {
+    return null;
+  }
+}
+function fromEnv(raw2) {
+  for (const enc2 of ["base64url", "base64", "hex"]) {
+    const buf = Buffer.from(raw2, enc2);
+    if (buf.length === KEY_BYTES) return buf;
+  }
+  return null;
+}
+function secretKeyPath() {
+  return join4(resolveHome(), "secret.key");
+}
+function secretKey() {
+  if (cached) return cached;
+  const override = process.env.HANOMAN_SECRET_KEY?.trim();
+  if (override) {
+    const key2 = fromEnv(override);
+    if (!key2) throw new Error(`HANOMAN_SECRET_KEY harus 32 byte (hex/base64), dapat ${override.length} karakter`);
+    cached = key2;
+    return key2;
+  }
+  const path2 = secretKeyPath();
+  if (existsSync5(path2)) {
+    const key2 = Buffer.from(readFileSync4(path2, "utf8").trim(), "base64url");
+    if (key2.length !== KEY_BYTES) throw new Error(`kunci di ${path2} rusak \u2014 panjangnya bukan 32 byte`);
+    cached = key2;
+    return key2;
+  }
+  const key = randomBytes(KEY_BYTES);
+  mkdirSync3(dirname6(path2), { recursive: true });
+  writeFileSync(path2, key.toString("base64url"), { mode: 384 });
+  chmodSync2(path2, 384);
+  cached = key;
+  return key;
+}
+function encryptSecret(plain) {
+  return encryptWithKey(plain, secretKey());
+}
+function decryptSecret(value) {
+  return decryptWithKey(value, secretKey());
+}
+var ENC_PREFIX, ALGO, IV_BYTES, KEY_BYTES, cached;
+var init_secret_box = __esm({
+  "src/services/secret-box.ts"() {
+    "use strict";
+    init_src2();
+    ENC_PREFIX = "enc:v1:";
+    ALGO = "aes-256-gcm";
+    IV_BYTES = 12;
+    KEY_BYTES = 32;
+    cached = null;
+  }
+});
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearConfig: () => clearConfig,
+  effectiveBool: () => effectiveBool,
+  effectiveInt: () => effectiveInt,
+  effectiveStr: () => effectiveStr,
+  loadConfig: () => loadConfig,
+  rawDbValue: () => rawDbValue,
+  setConfig: () => setConfig,
+  setConfigsAtomic: () => setConfigsAtomic,
+  sourceOf: () => sourceOf
+});
+async function loadConfig() {
+  const rows = await prisma.runtimeConfig.findMany();
+  const next = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (!isSecret(r.key)) {
+      next.set(r.key, r.value);
+      continue;
+    }
+    const plain = decryptSecret(r.value);
+    if (plain === null) {
+      console.error(`config: nilai '${r.key}' tak bisa didekripsi \u2014 diabaikan`);
+      continue;
+    }
+    next.set(r.key, plain);
+  }
+  cache = next;
+}
+function rawDbValue(key) {
+  return cache.get(key);
+}
+function effectiveStr(key) {
+  return cache.get(key) ?? process.env[key] ?? configEntry(key)?.default;
+}
+function effectiveInt(key) {
+  const v = effectiveStr(key);
+  return v === void 0 ? void 0 : Number(v);
+}
+function effectiveBool(key) {
+  const v = effectiveStr(key);
+  return v === "1" || v === "true";
+}
+function sourceOf(key) {
+  if (cache.has(key)) return "db";
+  if (process.env[key] !== void 0) return "env";
+  return "default";
+}
+async function setConfig(key, value) {
+  const stored = isSecret(key) ? encryptSecret(value) : value;
+  await prisma.runtimeConfig.upsert({ where: { key }, create: { key, value: stored }, update: { value: stored } });
+  cache.set(key, value);
+}
+async function setConfigsAtomic(values) {
+  await prisma.$transaction(Object.entries(values).map(([key, value]) => {
+    const stored = isSecret(key) ? encryptSecret(value) : value;
+    return prisma.runtimeConfig.upsert({ where: { key }, create: { key, value: stored }, update: { value: stored } });
+  }));
+  for (const [key, value] of Object.entries(values)) cache.set(key, value);
+}
+async function clearConfig(key) {
+  await prisma.runtimeConfig.deleteMany({ where: { key } });
+  cache.delete(key);
+}
+var cache, isSecret;
+var init_config2 = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_db();
+    init_src();
+    init_secret_box();
+    cache = /* @__PURE__ */ new Map();
+    isSecret = (key) => configEntry(key)?.kind === "secret";
+  }
+});
+
+// src/services/webhooks/ssrf.ts
+import { lookup as dnsLookup } from "node:dns/promises";
+import { isIPv4 } from "node:net";
+function validateWebhookUrl(raw2) {
+  let url2;
+  try {
+    url2 = new URL(raw2.trim());
+  } catch {
+    return { ok: false, error: "URL tak valid" };
+  }
+  if (url2.protocol !== "http:" && url2.protocol !== "https:")
+    return { ok: false, error: "hanya http atau https" };
+  if (url2.username || url2.password)
+    return { ok: false, error: "kredensial di URL tak diizinkan" };
+  if (!url2.hostname) return { ok: false, error: "hostname kosong" };
+  return { ok: true, url: url2 };
+}
+function blockedV4(ip) {
+  const p = ip.split(".").map(Number);
+  if (p.length !== 4 || p.some((n2) => !Number.isInteger(n2) || n2 < 0 || n2 > 255)) return true;
+  const [a, b] = p;
+  if (a === 0 || a === 127) return true;
+  if (a === 10) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 192 && b === 0) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function isBlockedAddress(ip) {
+  const v = ip.trim().toLowerCase();
+  if (!v) return true;
+  const mapped = v.startsWith("::ffff:") ? v.slice(7) : v;
+  if (isIPv4(mapped)) return blockedV4(mapped);
+  if (!v.includes(":")) return true;
+  if (v === "::" || v === "::1") return true;
+  if (v.startsWith("fe80") || v.startsWith("fec0")) return true;
+  if (/^f[cd]/.test(v)) return true;
+  if (v.startsWith("ff")) return true;
+  return false;
+}
+function checkUrlShape(raw2, allowPrivate) {
+  const parsed = validateWebhookUrl(raw2);
+  if (!parsed.ok) return parsed;
+  if (allowPrivate) return parsed;
+  const host2 = parsed.url.hostname.replace(/^\[|\]$/g, "");
+  const literal = isIPv4(host2) || host2.includes(":");
+  if (literal && isBlockedAddress(host2))
+    return {
+      ok: false,
+      error: `alamat internal ditolak (${host2}) \u2014 nyalakan "izinkan alamat internal" bila memang disengaja`
+    };
+  if (host2 === "localhost" || host2.endsWith(".localhost"))
+    return {
+      ok: false,
+      error: `alamat internal ditolak (${host2}) \u2014 nyalakan "izinkan alamat internal" bila memang disengaja`
+    };
+  return parsed;
+}
+async function checkDestination(url2, allowPrivate, lookup = defaultLookup) {
+  if (allowPrivate) return { ok: true };
+  const host2 = url2.hostname.replace(/^\[|\]$/g, "");
+  let addrs;
+  try {
+    addrs = await lookup(host2);
+  } catch (e) {
+    return { ok: false, error: `DNS gagal: ${e.message}` };
+  }
+  if (!addrs.length) return { ok: false, error: "DNS tak mengembalikan alamat" };
+  for (const a of addrs)
+    if (isBlockedAddress(a.address))
+      return {
+        ok: false,
+        error: `alamat internal ditolak (${a.address}) \u2014 nyalakan "izinkan alamat internal" bila memang disengaja`
+      };
+  return { ok: true };
+}
+var defaultLookup;
+var init_ssrf = __esm({
+  "src/services/webhooks/ssrf.ts"() {
+    "use strict";
+    defaultLookup = (host2) => dnsLookup(host2, { all: true });
+  }
+});
+
+// src/services/safe-outbound-request.ts
+import { lookup as dnsLookup2 } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+async function pinnedRequest(input) {
+  return new Promise((resolve19, reject2) => {
+    const transport = input.url.protocol === "https:" ? httpsRequest : httpRequest;
+    const req = transport({
+      protocol: input.url.protocol,
+      hostname: input.url.hostname,
+      port: input.url.port || void 0,
+      method: input.method,
+      path: `${input.url.pathname}${input.url.search}`,
+      headers: input.headers,
+      servername: input.url.hostname,
+      // Node >= 20 menyalakan `autoSelectFamily` secara default: socket memanggil `lookup` dengan
+      // `all: true` dan membaca `addresses[0].address` dari hasilnya. Menjawab dalam bentuk skalar
+      // di situ memberi `undefined` → ERR_INVALID_IP_ADDRESS sebelum satu paket pun keluar, dan
+      // pemanggil (sync tick, webhook) menelannya sebagai "offline". Kedua bentuk dijawab supaya
+      // pinning tetap benar apa pun setelan family-nya.
+      lookup: (_host, opts, callback) => opts.all ? callback(null, [{ address: input.address, family: input.family }]) : callback(null, input.address, input.family),
+      timeout: input.connectMs
+    }, (response) => {
+      const chunks = [];
+      let bytes = 0;
+      response.on("data", (chunk) => {
+        bytes += chunk.length;
+        if (bytes > input.maxResponseBytes) {
+          response.destroy(new Error("outbound response terlalu besar"));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      response.on("end", () => resolve19({
+        status: response.statusCode ?? 0,
+        headers: response.headers,
+        body: Buffer.concat(chunks)
+      }));
+    });
+    const timer9 = setTimeout(() => req.destroy(Object.assign(new Error("outbound timeout"), { name: "AbortError" })), input.totalMs);
+    timer9.unref?.();
+    req.once("close", () => clearTimeout(timer9));
+    req.once("error", reject2);
+    if (input.body) req.write(input.body);
+    req.end();
+  });
+}
+async function safeRequest(options2, deps = {}) {
+  if (options2.url.protocol !== "http:" && options2.url.protocol !== "https:") throw new Error("outbound scheme ditolak");
+  if (options2.url.username || options2.url.password) throw new Error("outbound credential URL ditolak");
+  const addresses = await (deps.lookupAll ?? defaultLookup2)(options2.url.hostname);
+  if (!addresses.length) throw new Error("DNS tak mengembalikan alamat");
+  if (!options2.allowPrivate) {
+    const blocked = addresses.find((row) => isBlockedAddress(row.address));
+    if (blocked) throw new Error(`alamat internal ditolak (${blocked.address})`);
+  }
+  const selected = addresses[0];
+  return (deps.request ?? pinnedRequest)({ ...options2, address: selected.address, family: selected.family });
+}
+var defaultLookup2;
+var init_safe_outbound_request = __esm({
+  "src/services/safe-outbound-request.ts"() {
+    "use strict";
+    init_ssrf();
+    defaultLookup2 = async (host2) => (await dnsLookup2(host2, { all: true })).map((row) => ({ address: row.address, family: row.family }));
+  }
+});
+
+// src/services/uploads.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, writeFile, readFile as readFile2, unlink, rm } from "node:fs/promises";
+import { join as join5, resolve as resolve8 } from "node:path";
+function extFor(mimeType) {
+  return EXT[mimeType] ?? ".bin";
+}
+function uploadDir() {
+  return resolve8(effectiveStr("HANOMAN_UPLOAD_DIR") ?? join5(resolveHome(), "uploads"));
+}
+function sessionUploadDir(sessionId2) {
+  if (!SESSION_ID.test(sessionId2)) throw new Error(`sessionId tak sah: ${sessionId2}`);
+  return join5(uploadDir(), "terminal", sessionId2);
+}
+async function saveSessionUpload(sessionId2, buf, mimeType) {
+  const dir2 = sessionUploadDir(sessionId2);
+  await mkdir(dir2, { recursive: true, mode: 448 });
+  const path2 = join5(dir2, `${randomUUID()}${extFor(mimeType)}`);
+  await writeFile(path2, buf, { mode: 384 });
+  return { path: path2, size: buf.length };
+}
+async function dropSessionUploads(sessionId2) {
+  let dir2;
+  try {
+    dir2 = sessionUploadDir(sessionId2);
+  } catch {
+    return;
+  }
+  await rm(dir2, { recursive: true, force: true }).catch(() => {
+  });
+}
+async function readUpload(storageKey) {
+  const safe = storageKey.replace(/[/\\]/g, "");
+  return readFile2(join5(uploadDir(), safe));
+}
+async function readUploadOrFetch(storageKey) {
+  const safe = storageKey.replace(/[/\\]/g, "");
+  const target2 = join5(uploadDir(), safe);
+  try {
+    return await readFile2(target2);
+  } catch {
+    const base2 = effectiveStr("SYNC_SERVER_URL");
+    const token = effectiveStr("SYNC_DEVICE_TOKEN");
+    if (!base2 || !token) throw new Error(`lampiran ${safe} tak ada lokal & bukan client sync`);
+    const url2 = new URL(`/api/sync/attachments/${encodeURIComponent(safe)}`, `${base2.replace(/\/$/, "")}/`);
+    const loopback = ["localhost", "127.0.0.1", "::1"].includes(url2.hostname);
+    const res = await safeRequest({
+      url: url2,
+      method: "GET",
+      headers: { authorization: `Bearer ${token}` },
+      allowPrivate: process.env.NODE_ENV !== "production" && loopback,
+      connectMs: 5e3,
+      totalMs: 15e3,
+      maxResponseBytes: 5 * 1024 * 1024
+    });
+    if (res.status < 200 || res.status >= 300) throw new Error(`fetch lampiran hub gagal: ${res.status}`);
+    const buf = res.body;
+    await mkdir(uploadDir(), { recursive: true, mode: 448 });
+    await writeFile(target2, buf, { mode: 384 });
+    return buf;
+  }
+}
+async function deleteUpload(storageKey) {
+  const safe = storageKey.replace(/[/\\]/g, "");
+  await unlink(join5(uploadDir(), safe)).catch(() => {
+  });
+}
+var EXT, SESSION_ID;
+var init_uploads = __esm({
+  "src/services/uploads.ts"() {
+    "use strict";
+    init_config2();
+    init_safe_outbound_request();
+    init_src2();
+    EXT = {
+      "image/png": ".png",
+      "image/jpeg": ".jpg",
+      "image/webp": ".webp"
+    };
+    SESSION_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+  }
+});
+
 // src/services/tui-dialog.ts
 function readChoiceDialog(paneText2) {
   const lines2 = paneText2.split("\n").map((l) => l.trimEnd());
@@ -9594,162 +9994,6 @@ var init_tui_dialog = __esm({
   }
 });
 
-// src/services/secret-box.ts
-import { chmodSync as chmodSync2, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync } from "node:fs";
-import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
-import { dirname as dirname6, join as join4 } from "node:path";
-function isEncrypted(value) {
-  return value.startsWith(ENC_PREFIX);
-}
-function encryptWithKey(plain, key) {
-  const iv = randomBytes(IV_BYTES);
-  const cipher = createCipheriv(ALGO, key, iv);
-  const body = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
-  const tag2 = cipher.getAuthTag();
-  return `${ENC_PREFIX}${iv.toString("base64url")}:${tag2.toString("base64url")}:${body.toString("base64url")}`;
-}
-function decryptWithKey(value, key) {
-  if (!isEncrypted(value)) return value;
-  const parts = value.slice(ENC_PREFIX.length).split(":");
-  if (parts.length !== 3) return null;
-  const [ivRaw, tagRaw, bodyRaw] = parts;
-  try {
-    const decipher = createDecipheriv(ALGO, key, Buffer.from(ivRaw, "base64url"));
-    decipher.setAuthTag(Buffer.from(tagRaw, "base64url"));
-    return Buffer.concat([decipher.update(Buffer.from(bodyRaw, "base64url")), decipher.final()]).toString("utf8");
-  } catch {
-    return null;
-  }
-}
-function fromEnv(raw2) {
-  for (const enc2 of ["base64url", "base64", "hex"]) {
-    const buf = Buffer.from(raw2, enc2);
-    if (buf.length === KEY_BYTES) return buf;
-  }
-  return null;
-}
-function secretKeyPath() {
-  return join4(resolveHome(), "secret.key");
-}
-function secretKey() {
-  if (cached) return cached;
-  const override = process.env.HANOMAN_SECRET_KEY?.trim();
-  if (override) {
-    const key2 = fromEnv(override);
-    if (!key2) throw new Error(`HANOMAN_SECRET_KEY harus 32 byte (hex/base64), dapat ${override.length} karakter`);
-    cached = key2;
-    return key2;
-  }
-  const path2 = secretKeyPath();
-  if (existsSync5(path2)) {
-    const key2 = Buffer.from(readFileSync4(path2, "utf8").trim(), "base64url");
-    if (key2.length !== KEY_BYTES) throw new Error(`kunci di ${path2} rusak \u2014 panjangnya bukan 32 byte`);
-    cached = key2;
-    return key2;
-  }
-  const key = randomBytes(KEY_BYTES);
-  mkdirSync3(dirname6(path2), { recursive: true });
-  writeFileSync(path2, key.toString("base64url"), { mode: 384 });
-  chmodSync2(path2, 384);
-  cached = key;
-  return key;
-}
-function encryptSecret(plain) {
-  return encryptWithKey(plain, secretKey());
-}
-function decryptSecret(value) {
-  return decryptWithKey(value, secretKey());
-}
-var ENC_PREFIX, ALGO, IV_BYTES, KEY_BYTES, cached;
-var init_secret_box = __esm({
-  "src/services/secret-box.ts"() {
-    "use strict";
-    init_src2();
-    ENC_PREFIX = "enc:v1:";
-    ALGO = "aes-256-gcm";
-    IV_BYTES = 12;
-    KEY_BYTES = 32;
-    cached = null;
-  }
-});
-
-// src/config.ts
-var config_exports = {};
-__export(config_exports, {
-  clearConfig: () => clearConfig,
-  effectiveBool: () => effectiveBool,
-  effectiveInt: () => effectiveInt,
-  effectiveStr: () => effectiveStr,
-  loadConfig: () => loadConfig,
-  rawDbValue: () => rawDbValue,
-  setConfig: () => setConfig,
-  setConfigsAtomic: () => setConfigsAtomic,
-  sourceOf: () => sourceOf
-});
-async function loadConfig() {
-  const rows = await prisma.runtimeConfig.findMany();
-  const next = /* @__PURE__ */ new Map();
-  for (const r of rows) {
-    if (!isSecret(r.key)) {
-      next.set(r.key, r.value);
-      continue;
-    }
-    const plain = decryptSecret(r.value);
-    if (plain === null) {
-      console.error(`config: nilai '${r.key}' tak bisa didekripsi \u2014 diabaikan`);
-      continue;
-    }
-    next.set(r.key, plain);
-  }
-  cache = next;
-}
-function rawDbValue(key) {
-  return cache.get(key);
-}
-function effectiveStr(key) {
-  return cache.get(key) ?? process.env[key] ?? configEntry(key)?.default;
-}
-function effectiveInt(key) {
-  const v = effectiveStr(key);
-  return v === void 0 ? void 0 : Number(v);
-}
-function effectiveBool(key) {
-  const v = effectiveStr(key);
-  return v === "1" || v === "true";
-}
-function sourceOf(key) {
-  if (cache.has(key)) return "db";
-  if (process.env[key] !== void 0) return "env";
-  return "default";
-}
-async function setConfig(key, value) {
-  const stored = isSecret(key) ? encryptSecret(value) : value;
-  await prisma.runtimeConfig.upsert({ where: { key }, create: { key, value: stored }, update: { value: stored } });
-  cache.set(key, value);
-}
-async function setConfigsAtomic(values) {
-  await prisma.$transaction(Object.entries(values).map(([key, value]) => {
-    const stored = isSecret(key) ? encryptSecret(value) : value;
-    return prisma.runtimeConfig.upsert({ where: { key }, create: { key, value: stored }, update: { value: stored } });
-  }));
-  for (const [key, value] of Object.entries(values)) cache.set(key, value);
-}
-async function clearConfig(key) {
-  await prisma.runtimeConfig.deleteMany({ where: { key } });
-  cache.delete(key);
-}
-var cache, isSecret;
-var init_config2 = __esm({
-  "src/config.ts"() {
-    "use strict";
-    init_db();
-    init_src();
-    init_secret_box();
-    cache = /* @__PURE__ */ new Map();
-    isSecret = (key) => configEntry(key)?.kind === "secret";
-  }
-});
-
 // src/services/session-sandbox.ts
 function assertRuntimeBoundary(env, runtime) {
   if (env.NODE_ENV !== "production") return;
@@ -9836,7 +10080,7 @@ var init_session_sandbox = __esm({
 import { spawn } from "node-pty";
 import { execFileSync } from "node:child_process";
 import { createRequire } from "node:module";
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdirSync as mkdirSync4, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname7 } from "node:path";
 import { tmpdir } from "node:os";
@@ -10283,6 +10527,8 @@ function killSession(id) {
   drop(id);
   tmux("kill-session", "-t", name(id));
   emitDeath({ sessionId: id, exitCode: p.exited ? p.code : null, transcript });
+  void dropSessionUploads(id).catch(() => {
+  });
   return true;
 }
 function detachAll() {
@@ -10313,6 +10559,7 @@ var init_pty = __esm({
     init_src();
     init_session_phases();
     init_session_id();
+    init_uploads();
     init_tui_dialog();
     init_config2();
     init_session_sandbox();
@@ -10348,7 +10595,7 @@ var init_pty = __esm({
       }
     };
     sq = (s2) => `'${s2.split("'").join("'\\''")}'`;
-    idFor = (specId) => specId ? sessionIdForSpec(specId) : randomUUID().slice(0, 8);
+    idFor = (specId) => specId ? sessionIdForSpec(specId) : randomUUID2().slice(0, 8);
     FMT = [
       "#{session_name}",
       "#{@hanoman_project}",
@@ -11382,9 +11629,9 @@ var init_config3 = __esm({
 // src/services/telegram/protocol.ts
 import { createHash as createHash2 } from "node:crypto";
 function normalizeTelegramCommand(text) {
-  const clean = text.trim();
-  const match = clean.match(/^\/([a-z0-9_]+)(?:@[a-z0-9_]+)?(?:\s+([\s\S]*))?$/i);
-  if (!match) return clean;
+  const clean2 = text.trim();
+  const match = clean2.match(/^\/([a-z0-9_]+)(?:@[a-z0-9_]+)?(?:\s+([\s\S]*))?$/i);
+  if (!match) return clean2;
   const args = match[2]?.trim().replace(/\s+/g, " ");
   return `/${match[1].toLowerCase()}${args ? ` ${args}` : ""}`;
 }
@@ -11450,19 +11697,19 @@ function inboundDigest(input) {
   return createHash2("sha256").update(`${input.updateId}\0${input.chatId}\0${input.userId}\0${input.kind}\0${input.text}`, "utf8").digest("hex");
 }
 function sanitizeTelegramOutput(text, exactSecrets = []) {
-  let clean = text.replace(ANSI, "").replace(CONTROLS, "");
+  let clean2 = text.replace(ANSI, "").replace(CONTROLS, "");
   for (const secret of [...exactSecrets].filter(Boolean).sort((a, b) => b.length - a.length)) {
-    clean = clean.split(secret).join("[REDACTED]");
+    clean2 = clean2.split(secret).join("[REDACTED]");
   }
-  for (const pattern of CREDENTIAL_PATTERNS) clean = clean.replace(pattern, "[REDACTED]");
-  return clean.trim();
+  for (const pattern of CREDENTIAL_PATTERNS) clean2 = clean2.replace(pattern, "[REDACTED]");
+  return clean2.trim();
 }
 function splitTelegramText(text, max = 4096, exactSecrets = []) {
   if (!Number.isInteger(max) || max < 1) throw new Error("max harus integer positif");
-  const clean = sanitizeTelegramOutput(text, exactSecrets);
-  if (!clean) return [];
+  const clean2 = sanitizeTelegramOutput(text, exactSecrets);
+  if (!clean2) return [];
   const chunks = [];
-  let rest = clean;
+  let rest = clean2;
   while (rest.length > max) {
     let cut = max;
     const before2 = rest.charCodeAt(cut - 1);
@@ -12584,161 +12831,6 @@ var init_conflicts = __esm({
   }
 });
 
-// src/services/webhooks/ssrf.ts
-import { lookup as dnsLookup } from "node:dns/promises";
-import { isIPv4 } from "node:net";
-function validateWebhookUrl(raw2) {
-  let url2;
-  try {
-    url2 = new URL(raw2.trim());
-  } catch {
-    return { ok: false, error: "URL tak valid" };
-  }
-  if (url2.protocol !== "http:" && url2.protocol !== "https:")
-    return { ok: false, error: "hanya http atau https" };
-  if (url2.username || url2.password)
-    return { ok: false, error: "kredensial di URL tak diizinkan" };
-  if (!url2.hostname) return { ok: false, error: "hostname kosong" };
-  return { ok: true, url: url2 };
-}
-function blockedV4(ip) {
-  const p = ip.split(".").map(Number);
-  if (p.length !== 4 || p.some((n2) => !Number.isInteger(n2) || n2 < 0 || n2 > 255)) return true;
-  const [a, b] = p;
-  if (a === 0 || a === 127) return true;
-  if (a === 10) return true;
-  if (a === 172 && b >= 16 && b <= 31) return true;
-  if (a === 192 && b === 168) return true;
-  if (a === 169 && b === 254) return true;
-  if (a === 100 && b >= 64 && b <= 127) return true;
-  if (a === 192 && b === 0) return true;
-  if (a >= 224) return true;
-  return false;
-}
-function isBlockedAddress(ip) {
-  const v = ip.trim().toLowerCase();
-  if (!v) return true;
-  const mapped = v.startsWith("::ffff:") ? v.slice(7) : v;
-  if (isIPv4(mapped)) return blockedV4(mapped);
-  if (!v.includes(":")) return true;
-  if (v === "::" || v === "::1") return true;
-  if (v.startsWith("fe80") || v.startsWith("fec0")) return true;
-  if (/^f[cd]/.test(v)) return true;
-  if (v.startsWith("ff")) return true;
-  return false;
-}
-function checkUrlShape(raw2, allowPrivate) {
-  const parsed = validateWebhookUrl(raw2);
-  if (!parsed.ok) return parsed;
-  if (allowPrivate) return parsed;
-  const host2 = parsed.url.hostname.replace(/^\[|\]$/g, "");
-  const literal = isIPv4(host2) || host2.includes(":");
-  if (literal && isBlockedAddress(host2))
-    return {
-      ok: false,
-      error: `alamat internal ditolak (${host2}) \u2014 nyalakan "izinkan alamat internal" bila memang disengaja`
-    };
-  if (host2 === "localhost" || host2.endsWith(".localhost"))
-    return {
-      ok: false,
-      error: `alamat internal ditolak (${host2}) \u2014 nyalakan "izinkan alamat internal" bila memang disengaja`
-    };
-  return parsed;
-}
-async function checkDestination(url2, allowPrivate, lookup = defaultLookup) {
-  if (allowPrivate) return { ok: true };
-  const host2 = url2.hostname.replace(/^\[|\]$/g, "");
-  let addrs;
-  try {
-    addrs = await lookup(host2);
-  } catch (e) {
-    return { ok: false, error: `DNS gagal: ${e.message}` };
-  }
-  if (!addrs.length) return { ok: false, error: "DNS tak mengembalikan alamat" };
-  for (const a of addrs)
-    if (isBlockedAddress(a.address))
-      return {
-        ok: false,
-        error: `alamat internal ditolak (${a.address}) \u2014 nyalakan "izinkan alamat internal" bila memang disengaja`
-      };
-  return { ok: true };
-}
-var defaultLookup;
-var init_ssrf = __esm({
-  "src/services/webhooks/ssrf.ts"() {
-    "use strict";
-    defaultLookup = (host2) => dnsLookup(host2, { all: true });
-  }
-});
-
-// src/services/safe-outbound-request.ts
-import { lookup as dnsLookup2 } from "node:dns/promises";
-import { request as httpRequest } from "node:http";
-import { request as httpsRequest } from "node:https";
-async function pinnedRequest(input) {
-  return new Promise((resolve19, reject2) => {
-    const transport = input.url.protocol === "https:" ? httpsRequest : httpRequest;
-    const req = transport({
-      protocol: input.url.protocol,
-      hostname: input.url.hostname,
-      port: input.url.port || void 0,
-      method: input.method,
-      path: `${input.url.pathname}${input.url.search}`,
-      headers: input.headers,
-      servername: input.url.hostname,
-      // Node >= 20 menyalakan `autoSelectFamily` secara default: socket memanggil `lookup` dengan
-      // `all: true` dan membaca `addresses[0].address` dari hasilnya. Menjawab dalam bentuk skalar
-      // di situ memberi `undefined` → ERR_INVALID_IP_ADDRESS sebelum satu paket pun keluar, dan
-      // pemanggil (sync tick, webhook) menelannya sebagai "offline". Kedua bentuk dijawab supaya
-      // pinning tetap benar apa pun setelan family-nya.
-      lookup: (_host, opts, callback) => opts.all ? callback(null, [{ address: input.address, family: input.family }]) : callback(null, input.address, input.family),
-      timeout: input.connectMs
-    }, (response) => {
-      const chunks = [];
-      let bytes = 0;
-      response.on("data", (chunk) => {
-        bytes += chunk.length;
-        if (bytes > input.maxResponseBytes) {
-          response.destroy(new Error("outbound response terlalu besar"));
-          return;
-        }
-        chunks.push(chunk);
-      });
-      response.on("end", () => resolve19({
-        status: response.statusCode ?? 0,
-        headers: response.headers,
-        body: Buffer.concat(chunks)
-      }));
-    });
-    const timer9 = setTimeout(() => req.destroy(Object.assign(new Error("outbound timeout"), { name: "AbortError" })), input.totalMs);
-    timer9.unref?.();
-    req.once("close", () => clearTimeout(timer9));
-    req.once("error", reject2);
-    if (input.body) req.write(input.body);
-    req.end();
-  });
-}
-async function safeRequest(options2, deps = {}) {
-  if (options2.url.protocol !== "http:" && options2.url.protocol !== "https:") throw new Error("outbound scheme ditolak");
-  if (options2.url.username || options2.url.password) throw new Error("outbound credential URL ditolak");
-  const addresses = await (deps.lookupAll ?? defaultLookup2)(options2.url.hostname);
-  if (!addresses.length) throw new Error("DNS tak mengembalikan alamat");
-  if (!options2.allowPrivate) {
-    const blocked = addresses.find((row) => isBlockedAddress(row.address));
-    if (blocked) throw new Error(`alamat internal ditolak (${blocked.address})`);
-  }
-  const selected = addresses[0];
-  return (deps.request ?? pinnedRequest)({ ...options2, address: selected.address, family: selected.family });
-}
-var defaultLookup2;
-var init_safe_outbound_request = __esm({
-  "src/services/safe-outbound-request.ts"() {
-    "use strict";
-    init_ssrf();
-    defaultLookup2 = async (host2) => (await dnsLookup2(host2, { all: true })).map((row) => ({ address: row.address, family: row.family }));
-  }
-});
-
 // ../node_modules/.pnpm/ws@8.21.0/node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
   "../node_modules/.pnpm/ws@8.21.0/node_modules/ws/lib/constants.js"(exports, module) {
@@ -18469,11 +18561,11 @@ var require_clean = __commonJS({
   "../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/clean.js"(exports, module) {
     "use strict";
     var parse3 = require_parse();
-    var clean = (version2, options2) => {
+    var clean2 = (version2, options2) => {
       const s2 = parse3(version2.trim().replace(/^[=v]+/, ""), options2);
       return s2 ? s2.version : null;
     };
-    module.exports = clean;
+    module.exports = clean2;
   }
 });
 
@@ -19870,7 +19962,7 @@ var require_semver2 = __commonJS({
     var identifiers = require_identifiers();
     var parse3 = require_parse();
     var valid = require_valid();
-    var clean = require_clean();
+    var clean2 = require_clean();
     var inc = require_inc();
     var diff = require_diff();
     var major = require_major();
@@ -19909,7 +20001,7 @@ var require_semver2 = __commonJS({
     module.exports = {
       parse: parse3,
       valid,
-      clean,
+      clean: clean2,
       inc,
       diff,
       major,
@@ -24267,7 +24359,7 @@ var require_multipart2 = __commonJS({
     var Busboy = require_main();
     var os = __require("node:os");
     var fp = require_fastify_plugin();
-    var { createWriteStream } = __require("node:fs");
+    var { createWriteStream: createWriteStream2 } = __require("node:fs");
     var { unlink: unlink6 } = __require("node:fs/promises");
     var path2 = __require("node:path");
     var { generateId } = require_generateId();
@@ -24647,7 +24739,7 @@ var require_multipart2 = __commonJS({
             continue;
           }
           const filepath = path2.join(tmpdir5, generateId() + path2.extname(part.filename || "file" + i++));
-          const target2 = createWriteStream(filepath);
+          const target2 = createWriteStream2(filepath);
           try {
             this.tmpUploads.push(filepath);
             await pump2(part.file, target2);
@@ -24824,13 +24916,13 @@ init_src();
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { existsSync as existsSync6, rmSync as rmSync2 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 
 // src/services/safe-repo-path.ts
 import { constants } from "node:fs";
-import { lstat, mkdir, open as open2, realpath, rename, unlink } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join5, relative, resolve as resolve8, sep as sep2 } from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { lstat, mkdir as mkdir2, open as open2, realpath, rename, unlink as unlink2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join6, relative, resolve as resolve9, sep as sep2 } from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { closeSync, fstatSync, lstatSync, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync5, realpathSync as realpathSync2, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
 var PathContainmentError = class extends Error {
   code = "PATH_CONTAINMENT";
@@ -24859,9 +24951,9 @@ async function ensureRepoParents(root, rel) {
   const parts = components(rel).slice(0, -1);
   let current = base2;
   for (const part of parts) {
-    current = join5(current, part);
+    current = join6(current, part);
     try {
-      await mkdir(current, { mode: 448 });
+      await mkdir2(current, { mode: 448 });
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
     }
@@ -24876,7 +24968,7 @@ function ensureRepoParentsSync(root, rel) {
   const parts = components(rel).slice(0, -1);
   let current = base2;
   for (const part of parts) {
-    current = join5(current, part);
+    current = join6(current, part);
     try {
       mkdirSync5(current, { mode: 448 });
     } catch (error) {
@@ -24892,8 +24984,9 @@ async function resolveRepoEntry(root, rel, opts = {}) {
   const parts = components(rel);
   let current = base2;
   for (let i = 0; i < parts.length; i++) {
-    current = join5(current, parts[i]);
+    current = join6(current, parts[i]);
     const stat2 = await lstat(current).catch((error) => {
+      if (error.code === "ENOENT" && opts.allowMissingTail) return null;
       if (error.code === "ENOENT" && opts.allowMissingFinal && i === parts.length - 1) return null;
       return denied("komponen tidak ada");
     });
@@ -24901,8 +24994,8 @@ async function resolveRepoEntry(root, rel, opts = {}) {
     if (stat2.isSymbolicLink()) denied("symlink");
     if (i < parts.length - 1 && !stat2.isDirectory()) denied("parent bukan direktori");
   }
-  if (!beneath(base2, resolve8(current))) denied("keluar root");
-  const parent = resolve8(current, "..");
+  if (!beneath(base2, resolve9(current))) denied("keluar root");
+  const parent = resolve9(current, "..");
   const parentReal = await realpath(parent).catch(() => denied("parent tidak ada"));
   if (!beneath(base2, parentReal)) denied("parent keluar root");
   return { root: base2, path: current, parent: parentReal };
@@ -24912,7 +25005,7 @@ function assertSafeRepoPathSync(root, rel, allowMissingFinal = false, allowMissi
   const parts = components(rel);
   let current = base2;
   for (let i = 0; i < parts.length; i++) {
-    current = join5(current, parts[i]);
+    current = join6(current, parts[i]);
     try {
       const stat2 = lstatSync(current);
       if (stat2.isSymbolicLink()) denied("symlink");
@@ -24923,7 +25016,7 @@ function assertSafeRepoPathSync(root, rel, allowMissingFinal = false, allowMissi
       throw error;
     }
   }
-  if (!beneath(base2, resolve8(current))) denied("keluar root");
+  if (!beneath(base2, resolve9(current))) denied("keluar root");
   return current;
 }
 function readRepoFileSync(root, rel) {
@@ -24939,10 +25032,10 @@ function readRepoFileSync(root, rel) {
 function writeRepoFileAtomicSync(root, rel, data) {
   ensureRepoParentsSync(root, rel);
   const path2 = assertSafeRepoPathSync(root, rel, true);
-  const parent = resolve8(path2, "..");
+  const parent = resolve9(path2, "..");
   const parentRel = relative(realpathSync2(root), parent);
   if (parentRel) assertSafeRepoPathSync(root, parentRel);
-  const temp = join5(parent, `.hanoman-${randomUUID2()}.tmp`);
+  const temp = join6(parent, `.hanoman-${randomUUID3()}.tmp`);
   const fd = openSync(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0), 384);
   try {
     writeFileSync3(fd, data);
@@ -24986,10 +25079,10 @@ async function writeRepoFileAtomic(root, rel, data) {
     return denied("final component tak terbaca");
   });
   if (current?.isSymbolicLink() || current && !current.isFile()) denied("target bukan file regular");
-  await mkdir(entry.parent, { recursive: false, mode: 448 }).catch((error) => {
+  await mkdir2(entry.parent, { recursive: false, mode: 448 }).catch((error) => {
     if (error.code !== "EEXIST") throw error;
   });
-  const temp = join5(entry.parent, `.hanoman-${randomUUID2()}.tmp`);
+  const temp = join6(entry.parent, `.hanoman-${randomUUID3()}.tmp`);
   const handle = await open2(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0), 384);
   try {
     await handle.writeFile(data);
@@ -25004,7 +25097,7 @@ async function writeRepoFileAtomic(root, rel, data) {
     if (finalAgain?.isSymbolicLink() || finalAgain && !finalAgain.isFile()) denied("target berubah");
     await rename(temp, entry.path);
   } catch (error) {
-    await unlink(temp).catch(() => {
+    await unlink2(temp).catch(() => {
     });
     throw error;
   }
@@ -25034,7 +25127,7 @@ function docsDirOf(repoDir) {
 }
 function resolveIndex(repoDir, docsDir) {
   const rel = `${docsDir}/README.md`;
-  return existsSync6(resolve9(repoDir, rel)) ? rel : "";
+  return existsSync6(resolve10(repoDir, rel)) ? rel : "";
 }
 var catOf = (rel) => rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : ".";
 var nameOf = (rel) => rel.includes("/") ? rel.slice(rel.lastIndexOf("/") + 1) : rel;
@@ -25411,7 +25504,7 @@ import { existsSync as existsSync7 } from "node:fs";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 import { rmSync as rmSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var sanitize = (id) => id.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
 var sourceBranch = (specId) => `hanoman/${sanitize(specId)}`;
 var exec3 = promisify3(execFile3);
@@ -25455,7 +25548,7 @@ async function integrateBranch(repoDir, src, op, target2) {
   const tgt = await resolveTarget(repoDir, target2);
   if (!tgt) return { status: "error", code: 400, error: `target "${target2}" tidak dikenal` };
   await sh(repoDir, ["fetch", "origin"]);
-  const wt = join6(repoDir, ".worktrees", `merge-${sanitize(src.mergeId)}`);
+  const wt = join7(repoDir, ".worktrees", `merge-${sanitize(src.mergeId)}`);
   await reclaim(repoDir, wt);
   const baseRef = op === "merge" ? tgt.ref : source;
   const baseSha = await out(repoDir, ["rev-parse", "--verify", "--end-of-options", `${baseRef}^{commit}`]);
@@ -25516,7 +25609,7 @@ async function mergeIntoCurrent(repoDir, source, opts = {}) {
   const src = await resolveGraphSource(repoDir, source);
   if (!src) return { status: "error", code: 400, error: `source "${source}" tak dikenal` };
   await sh(repoDir, ["fetch", "origin"]);
-  const wt = join6(repoDir, ".worktrees", `merge-${sanitize(current)}`);
+  const wt = join7(repoDir, ".worktrees", `merge-${sanitize(current)}`);
   await reclaim(repoDir, wt);
   const baseSha = await out(repoDir, ["rev-parse", "--verify", "--end-of-options", `refs/heads/${current}^{commit}`]);
   if (!await ok(repoDir, ["worktree", "add", "--detach", "-q", wt, baseSha]))
@@ -25554,7 +25647,7 @@ async function replayCurrent(repoDir, source, cmd) {
   const current = await out(repoDir, ["rev-parse", "--abbrev-ref", "HEAD"]);
   if (!current || current === "HEAD")
     return { status: "error", code: 409, error: "HEAD detached \u2014 checkout sebuah branch dulu" };
-  const wt = join6(repoDir, ".worktrees", `merge-${sanitize(current)}`);
+  const wt = join7(repoDir, ".worktrees", `merge-${sanitize(current)}`);
   await reclaim(repoDir, wt);
   const baseSha = await out(repoDir, ["rev-parse", "--verify", "--end-of-options", `refs/heads/${current}^{commit}`]);
   if (!await ok(repoDir, ["worktree", "add", "--detach", "-q", wt, baseSha]))
@@ -25601,24 +25694,24 @@ init_db();
 // src/services/spec-review.ts
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { mkdtemp, copyFile, rm } from "node:fs/promises";
+import { mkdtemp, copyFile, rm as rm2 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join7, resolve as resolve10 } from "node:path";
+import { join as join8, resolve as resolve11 } from "node:path";
 var exec4 = promisify4(execFile4);
 var GIT3 = { maxBuffer: 1 << 24 };
 var MAX = 256 * 1024;
-var worktreeDir = (repoDir, specId) => join7(repoDir, ".worktrees", specId.toLowerCase().replace(/[^a-z0-9_-]/g, "_"));
+var worktreeDir = (repoDir, specId) => join8(repoDir, ".worktrees", specId.toLowerCase().replace(/[^a-z0-9_-]/g, "_"));
 async function withTempIndex(wt, fn2) {
   const idx = (await exec4("git", ["rev-parse", "--git-path", "index"], { cwd: wt, ...GIT3 })).stdout.trim();
-  const dir2 = await mkdtemp(join7(tmpdir2(), "hanoman-idx-"));
-  const tmp = join7(dir2, "index");
-  await copyFile(resolve10(wt, idx), tmp);
+  const dir2 = await mkdtemp(join8(tmpdir2(), "hanoman-idx-"));
+  const tmp = join8(dir2, "index");
+  await copyFile(resolve11(wt, idx), tmp);
   const env = { ...process.env, GIT_INDEX_FILE: tmp };
   try {
     await exec4("git", ["add", "-A", "-N"], { cwd: wt, env, ...GIT3 });
     return await fn2(env);
   } finally {
-    await rm(dir2, { recursive: true, force: true });
+    await rm2(dir2, { recursive: true, force: true });
   }
 }
 var splitZ = (s2) => s2.split("\0").filter(Boolean);
@@ -25822,7 +25915,7 @@ init_notifications();
 
 // src/services/session-result.ts
 init_db();
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 var WHITELIST = [
   "projectId",
   "specId",
@@ -25836,7 +25929,7 @@ var WHITELIST = [
   "author"
 ];
 async function recordSessionResult(input) {
-  const id = randomUUID3();
+  const id = randomUUID4();
   const data = { id };
   for (const f of WHITELIST) if (input[f] !== void 0 && input[f] !== null) data[f] = input[f];
   if (data.status === void 0) data.status = "done";
@@ -29185,7 +29278,7 @@ import { promisify as promisify7 } from "node:util";
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
 import { existsSync as existsSync9 } from "node:fs";
-import { resolve as resolve11 } from "node:path";
+import { resolve as resolve12 } from "node:path";
 var exec6 = promisify6(execFile6);
 var GIT5 = { maxBuffer: 1 << 24 };
 var MAX2 = 256 * 1024;
@@ -29193,7 +29286,7 @@ var splitZ2 = (s2) => s2.split("\0").filter(Boolean);
 function repoAbsPath(repoDir, rel, allowMissingFinal = false) {
   if (rel.split(/[\\/]/).includes(".git")) throw new Error("tidak boleh menyentuh .git");
   assertSafeRepoPathSync(repoDir, rel, allowMissingFinal, true);
-  return resolve11(repoDir, rel);
+  return resolve12(repoDir, rel);
 }
 async function listRepoTree(repoDir, ref = "") {
   if (!repoDir || !existsSync9(repoDir)) return [];
@@ -29284,10 +29377,10 @@ async function listGraph(repoDir, limit = 200, opts = {}) {
       const [sha, parents, author, at, subject, refs2] = line.split(US);
       const tags = [], branchRefs = [];
       for (const d of (refs2 ?? "").split(",").map((r) => r.trim()).filter(Boolean)) {
-        const clean = d.replace(/^HEAD -> /, "");
-        if (clean === "HEAD") continue;
-        if (clean.startsWith("tag: ")) tags.push(clean.slice(5));
-        else branchRefs.push(clean);
+        const clean2 = d.replace(/^HEAD -> /, "");
+        if (clean2 === "HEAD") continue;
+        if (clean2.startsWith("tag: ")) tags.push(clean2.slice(5));
+        else branchRefs.push(clean2);
       }
       return {
         sha,
@@ -29763,6 +29856,85 @@ async function deleteBranches(repoDir, names, opts) {
   return { base: report.base, results };
 }
 
+// src/services/repo-fs.ts
+import { lstat as lstat2, rename as rename2, rm as rm3 } from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+import { join as join9 } from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { pipeline } from "node:stream/promises";
+var EntryExistsError = class extends Error {
+  code = "ENTRY_EXISTS";
+};
+var EntryMissingError = class extends Error {
+  code = "ENTRY_MISSING";
+};
+var EntryTargetInsideError = class extends Error {
+  code = "ENTRY_TARGET_INSIDE";
+};
+function assertNotGit(rel) {
+  if (rel.split(/[\\/]/).includes(".git"))
+    throw new PathContainmentError("repository path ditolak: tidak boleh menyentuh .git");
+}
+var clean = (s2) => s2.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+function joinRel(dir2, name2) {
+  const d = clean(dir2), n2 = clean(name2);
+  if (!n2) throw new PathContainmentError("repository path ditolak: nama berkas kosong");
+  return d ? `${d}/${n2}` : n2;
+}
+async function entryKind(repoDir, rel) {
+  assertNotGit(rel);
+  const { path: path2 } = await resolveRepoEntry(repoDir, rel, { allowMissingTail: true });
+  const st = await lstat2(path2).catch(() => null);
+  if (!st) return null;
+  return st.isDirectory() ? "dir" : "file";
+}
+async function createEntry(repoDir, rel, kind) {
+  if (await entryKind(repoDir, rel)) throw new EntryExistsError(`sudah ada: ${rel}`);
+  await writeRepoFileAtomic(repoDir, kind === "dir" ? `${clean(rel)}/.gitkeep` : rel, "");
+  return { path: rel };
+}
+async function renameEntry(repoDir, from, to) {
+  const kind = await entryKind(repoDir, from);
+  if (!kind) throw new EntryMissingError(`tidak ada: ${from}`);
+  if (await entryKind(repoDir, to)) throw new EntryExistsError(`sudah ada: ${to}`);
+  if (kind === "dir" && `${clean(to)}/`.startsWith(`${clean(from)}/`))
+    throw new EntryTargetInsideError("tujuan di dalam sumber");
+  await ensureRepoParents(repoDir, to);
+  const src = await resolveRepoEntry(repoDir, from);
+  const dst = await resolveRepoEntry(repoDir, to, { allowMissingFinal: true });
+  await rename2(src.path, dst.path);
+  return { from, to };
+}
+async function deleteEntry(repoDir, rel) {
+  const kind = await entryKind(repoDir, rel);
+  if (!kind) throw new EntryMissingError(`tidak ada: ${rel}`);
+  const { path: path2 } = await resolveRepoEntry(repoDir, rel);
+  await rm3(path2, { recursive: kind === "dir", force: false });
+  return { path: rel, kind };
+}
+async function saveUpload(repoDir, rel, source, opts = {}) {
+  assertNotGit(rel);
+  await ensureRepoParents(repoDir, rel);
+  const entry = await resolveRepoEntry(repoDir, rel, { allowMissingFinal: true });
+  const current = await lstat2(entry.path).catch(() => null);
+  if (current && !opts.overwrite) return { status: "exists" };
+  if (current && !current.isFile())
+    throw new PathContainmentError("repository path ditolak: target bukan file regular");
+  const temp = join9(entry.parent, `.hanoman-${randomUUID5()}.tmp`);
+  try {
+    await pipeline(source, createWriteStream(temp, { flags: "wx", mode: 384 }));
+    if (opts.isTruncated?.()) {
+      await rm3(temp, { force: true });
+      return { status: "too-large" };
+    }
+    await rename2(temp, entry.path);
+    return { status: "written" };
+  } catch (error) {
+    await rm3(temp, { force: true });
+    throw error;
+  }
+}
+
 // src/routes/ide.ts
 async function repoOf(id) {
   const p = await prisma.project.findUnique({ where: { id } });
@@ -29781,6 +29953,19 @@ async function lockInputs(id) {
     sessionBranches: new Set(sessions)
   };
 }
+function entryError(reply, e) {
+  if (e instanceof EntryMissingError) return reply.code(404).send({ error: "not found" });
+  if (e instanceof EntryExistsError) return reply.code(409).send({ error: "sudah ada" });
+  if (e instanceof EntryTargetInsideError) return reply.code(400).send({ error: "tujuan di dalam sumber" });
+  return reply.code(400).send({ error: e.message });
+}
+var UPLOAD_LIMITS = {
+  fileSize: 100 * 1024 * 1024,
+  files: 1e3,
+  fields: 10,
+  fieldSize: 1024 * 1024
+};
+var UPLOAD_TOTAL_MAX = 2 * 1024 * 1024 * 1024;
 async function ide_default(app2) {
   app2.get("/projects/:id/tree", async (req, reply) => {
     const repoDir = await repoOf(req.params.id);
@@ -29845,6 +30030,102 @@ async function ide_default(app2) {
       return reply.code(400).send({ error: e.message });
     }
   });
+  app2.post("/projects/:id/entry", async (req, reply) => {
+    const repoDir = await repoOf(req.params.id);
+    if (repoDir === void 0) return reply.code(404).send({ error: "not found" });
+    if (!repoDir) return reply.code(400).send({ error: "project tidak punya repoDir" });
+    const b = req.body;
+    if (!b?.path || typeof b.path !== "string") return reply.code(400).send({ error: "path wajib" });
+    if (b.kind !== "file" && b.kind !== "dir") return reply.code(400).send({ error: "kind harus file atau dir" });
+    try {
+      return reply.code(201).send(await createEntry(repoDir, b.path, b.kind));
+    } catch (e) {
+      return entryError(reply, e);
+    }
+  });
+  app2.patch("/projects/:id/entry", async (req, reply) => {
+    const repoDir = await repoOf(req.params.id);
+    if (repoDir === void 0) return reply.code(404).send({ error: "not found" });
+    if (!repoDir) return reply.code(400).send({ error: "project tidak punya repoDir" });
+    const b = req.body;
+    if (!b?.from || !b?.to || typeof b.from !== "string" || typeof b.to !== "string")
+      return reply.code(400).send({ error: "from & to wajib" });
+    try {
+      return await renameEntry(repoDir, b.from, b.to);
+    } catch (e) {
+      return entryError(reply, e);
+    }
+  });
+  app2.delete("/projects/:id/entry", async (req, reply) => {
+    const repoDir = await repoOf(req.params.id);
+    if (repoDir === void 0) return reply.code(404).send({ error: "not found" });
+    if (!repoDir) return reply.code(400).send({ error: "project tidak punya repoDir" });
+    const { path: path2 } = req.query;
+    if (!path2) return reply.code(400).send({ error: "path wajib" });
+    try {
+      return await deleteEntry(repoDir, path2);
+    } catch (e) {
+      return entryError(reply, e);
+    }
+  });
+  app2.post("/projects/:id/upload", async (req, reply) => {
+    const repoDir = await repoOf(req.params.id);
+    if (repoDir === void 0) return reply.code(404).send({ error: "not found" });
+    if (!repoDir) return reply.code(400).send({ error: "project tidak punya repoDir" });
+    if (!req.isMultipart?.()) return reply.code(400).send({ error: "butuh multipart/form-data" });
+    const totalMax = Number(process.env.HANOMAN_IDE_UPLOAD_MAX_BYTES) || UPLOAD_TOTAL_MAX;
+    let dir2 = "", overwrite = false, manifest = null, seen = 0, total = 0;
+    const written = [];
+    const skipped2 = [];
+    for await (const part of req.parts({ limits: UPLOAD_LIMITS })) {
+      if (part.type === "field") {
+        if (part.fieldname === "dir") dir2 = String(part.value ?? "");
+        else if (part.fieldname === "overwrite") overwrite = part.value === "1" || part.value === "true";
+        else if (part.fieldname === "manifest") {
+          try {
+            const parsed = JSON.parse(String(part.value));
+            if (!Array.isArray(parsed) || parsed.some((p) => typeof p !== "string")) throw new Error("bentuk");
+            manifest = parsed;
+          } catch {
+            return reply.code(400).send({ error: "manifest tak sah" });
+          }
+        }
+        continue;
+      }
+      const name2 = manifest ? manifest[seen] : part.filename;
+      seen++;
+      if (name2 === void 0) {
+        part.file.resume();
+        return reply.code(400).send({ error: "manifest tak cocok dengan berkas" });
+      }
+      let rel = name2;
+      try {
+        rel = joinRel(dir2, name2);
+        if (total >= totalMax) {
+          part.file.resume();
+          skipped2.push({ path: rel, reason: "budget" });
+          continue;
+        }
+        const r = await saveUpload(repoDir, rel, part.file, {
+          overwrite,
+          isTruncated: () => part.file.truncated === true
+        });
+        if (r.status === "written") {
+          written.push(rel);
+          total += Number(part.file.bytesRead ?? 0);
+        } else {
+          part.file.resume();
+          skipped2.push({ path: rel, reason: r.status });
+        }
+      } catch {
+        part.file.resume();
+        skipped2.push({ path: name2, reason: "denied" });
+      }
+    }
+    if (manifest && seen !== manifest.length)
+      return reply.code(400).send({ error: "manifest tak cocok dengan berkas" });
+    return { written, skipped: skipped2 };
+  });
   app2.get("/projects/:id/graph", async (req, reply) => {
     const repoDir = await repoOf(req.params.id);
     if (repoDir === void 0) return reply.code(404).send({ error: "not found" });
@@ -30083,14 +30364,14 @@ async function finishGraphOp(reply, id, repoDir, r, verb) {
 // src/routes/fs.ts
 import { readdir } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { resolve as resolve12, dirname as dirname9, join as join8 } from "node:path";
+import { resolve as resolve13, dirname as dirname9, join as join10 } from "node:path";
 async function fs_default(app2) {
   app2.get("/fs/browse", async (req, reply) => {
     const q = req.query.path;
-    const dir2 = q && q.trim() ? resolve12(q.trim()) : homedir4();
+    const dir2 = q && q.trim() ? resolve13(q.trim()) : homedir4();
     try {
       const ents = await readdir(dir2, { withFileTypes: true });
-      const entries = ents.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, path: join8(dir2, e.name) })).sort((a, b) => a.name.localeCompare(b.name));
+      const entries = ents.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, path: join10(dir2, e.name) })).sort((a, b) => a.name.localeCompare(b.name));
       const parent = dirname9(dir2);
       return { path: dir2, parent: parent === dir2 ? null : parent, entries };
     } catch {
@@ -30524,11 +30805,11 @@ function installCommand(m, agent, shell = shellBin()) {
 }
 
 // src/services/session-worktree.ts
-import { resolve as resolve13, sep as sep3 } from "node:path";
+import { resolve as resolve14, sep as sep3 } from "node:path";
 function ownsWorktree(repoDir, cwd) {
-  const base2 = resolve13(repoDir);
-  const dir2 = resolve13(cwd);
-  const container = resolve13(base2, ".worktrees");
+  const base2 = resolve14(repoDir);
+  const dir2 = resolve14(cwd);
+  const container = resolve14(base2, ".worktrees");
   return dir2 !== base2 && dir2 !== container && dir2.startsWith(container + sep3);
 }
 
@@ -30536,15 +30817,15 @@ function ownsWorktree(repoDir, cwd) {
 init_src2();
 init_db();
 import { execFile as execFile8 } from "node:child_process";
-import { readdir as readdir2, rm as rm2 } from "node:fs/promises";
+import { readdir as readdir2, rm as rm4 } from "node:fs/promises";
 import { promisify as promisify9 } from "node:util";
-import { join as join9, resolve as resolve14 } from "node:path";
+import { join as join11, resolve as resolve15 } from "node:path";
 init_notifications();
 var TICK_MS = 6e4;
-var trashDirOf = (repoDir) => resolve14(repoDir, ".worktrees", ".trash");
+var trashDirOf = (repoDir) => resolve15(repoDir, ".worktrees", ".trash");
 var exec8 = promisify9(execFile8);
 var prodReaperDeps = {
-  rm: (path2) => rm2(path2, { recursive: true, force: true }),
+  rm: (path2) => rm4(path2, { recursive: true, force: true }),
   prune: async (repoDir) => {
     try {
       await exec8("git", ["worktree", "prune"], { cwd: repoDir, timeout: 3e4 });
@@ -30598,7 +30879,7 @@ async function sweepRepo(repoDir, projectId, deps = prodReaperDeps) {
   }
   let removed = 0;
   for (const entry of entries) {
-    const path2 = join9(dir2, entry);
+    const path2 = join11(dir2, entry);
     const known = pending.get(path2);
     const row = known ?? { path: path2, repoDir, projectId, entry, sessionId: sessionIdOf(entry), since: Date.now() };
     pending.set(path2, row);
@@ -30642,6 +30923,8 @@ function startWorktreeReaper(deps = prodReaperDeps) {
 init_notifications();
 init_stage_machine();
 init_pty();
+init_uploads();
+var ATTACHMENT_MIME = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp"]);
 var TERMINAL_WS_MESSAGES_PER_MINUTE = 6e3;
 async function advanceStage(specId, repoDir, sessionId2, flow, worktree) {
   const next = stageForRun(readPhases(phaseFilePath(repoDir, sessionId2), flow), worktree, specId);
@@ -30965,6 +31248,18 @@ async function terminal_default(app2, opts) {
     killSession(id);
     return reply.code(202).send({ cleanup: null });
   });
+  app2.post("/terminal/sessions/:id/attachments", async (req, reply) => {
+    const { id } = req.params;
+    if (!getSession(id)) return reply.code(404).send({ error: "not found" });
+    if (!req.isMultipart?.()) return reply.code(400).send({ error: "butuh multipart/form-data" });
+    const part = await req.file?.();
+    if (!part) return reply.code(400).send({ error: "unggahan tak valid" });
+    const buf = await part.toBuffer();
+    if (part.file?.truncated) return reply.code(413).send({ error: "berkas melebihi 5 MB" });
+    if (!ATTACHMENT_MIME.has(part.mimetype)) return reply.code(415).send({ error: "tipe berkas tak didukung" });
+    const { path: path2 } = await saveSessionUpload(id, buf, part.mimetype);
+    return { path: path2 };
+  });
   app2.get("/terminal/sessions/:id/ws", {
     websocket: true,
     preValidation: async (req, reply) => {
@@ -31203,7 +31498,7 @@ init_config2();
 import { spawn as spawn3 } from "node:child_process";
 import { mkdtempSync, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname10, join as join10 } from "node:path";
+import { dirname as dirname10, join as join12 } from "node:path";
 var sshBin = () => effectiveStr("HANOMAN_SSH_BIN") ?? "ssh";
 function consoleArgv(t) {
   return [
@@ -31218,8 +31513,8 @@ function consoleArgv(t) {
   ];
 }
 function askpassScript() {
-  const dir2 = mkdtempSync(join10(tmpdir3(), "hanoman-askpass-"));
-  const path2 = join10(dir2, "askpass.sh");
+  const dir2 = mkdtempSync(join12(tmpdir3(), "hanoman-askpass-"));
+  const path2 = join12(dir2, "askpass.sh");
   writeFileSync4(path2, `#!/bin/sh
 printf '%s' "$HANOMAN_SSH_PASSWORD"
 `, { mode: 448 });
@@ -31280,15 +31575,15 @@ function sshExec(t, remoteCmd, opts = {}) {
 // src/services/vps-audit.ts
 init_db();
 import { readFileSync as readFileSync7 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join14 } from "node:path";
 
 // src/runner/deps.ts
 import { existsSync as existsSync11 } from "node:fs";
-import { dirname as dirname11, join as join11 } from "node:path";
+import { dirname as dirname11, join as join13 } from "node:path";
 function repoRootFrom(startDir) {
   let dir2 = startDir;
   for (let i = 0; i < 8; i++) {
-    if (existsSync11(join11(dir2, "pnpm-workspace.yaml"))) return dir2;
+    if (existsSync11(join13(dir2, "pnpm-workspace.yaml"))) return dir2;
     const parent = dirname11(dir2);
     if (parent === dir2) break;
     dir2 = parent;
@@ -31394,7 +31689,7 @@ function parseHealth(out3) {
   return { uptime: h.uptime ?? "", disk: h.disk ?? "", mem: h.mem ?? "", load: h.load ?? "" };
 }
 var target = (v) => ({ host: v.host, port: v.port, user: v.user, keyPath: v.keyPath });
-var scriptPath = (f) => join12(repoRoot(), "server", "scripts", "vps", f);
+var scriptPath = (f) => join14(repoRoot(), "server", "scripts", "vps", f);
 async function itemStatesOf(vpsId) {
   const rows = await prisma.vpsItemState.findMany({ where: { vpsId } });
   return Object.fromEntries(rows.map((s2) => [s2.itemId, { na: s2.na, attested: s2.attested }]));
@@ -31543,11 +31838,11 @@ init_config2();
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync9 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join13 } from "node:path";
-var keyDir = () => effectiveStr("HANOMAN_SSH_KEY_DIR") ?? join13(homedir5(), ".hanoman");
+import { join as join15 } from "node:path";
+var keyDir = () => effectiveStr("HANOMAN_SSH_KEY_DIR") ?? join15(homedir5(), ".hanoman");
 function ensureHanomanKey() {
   const dir2 = keyDir();
-  const privPath = join13(dir2, "id_ed25519");
+  const privPath = join15(dir2, "id_ed25519");
   const pubPath = `${privPath}.pub`;
   if (!existsSync12(privPath)) {
     mkdirSync8(dir2, { recursive: true, mode: 448 });
@@ -31785,7 +32080,7 @@ init_config2();
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { readFileSync as readFileSync11 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 var USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 var TTL_MS2 = 3e4;
 var lastOk = null;
@@ -31798,7 +32093,7 @@ var LABELS = {
 var humanize = (k) => k.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
 function credsFile() {
-  return join14(effectiveStr("CLAUDE_CONFIG_DIR") ?? join14(homedir7(), ".claude"), ".credentials.json");
+  return join16(effectiveStr("CLAUDE_CONFIG_DIR") ?? join16(homedir7(), ".claude"), ".credentials.json");
 }
 function readAccessToken() {
   if (process.platform === "darwin" && !effectiveStr("CLAUDE_CONFIG_DIR")) {
@@ -31872,14 +32167,14 @@ async function getLimits() {
 // src/services/codex-limits.ts
 import { open as open3, readdir as readdir3, stat } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 var TTL_MS3 = 3e4;
 var STALE_AFTER_MS = 12 * 36e5;
 var TAIL_BYTES = 512 * 1024;
 var MAX_FILES = 8;
 var cache2 = null;
 var freshUntil2 = 0;
-var codexSessionsDir = () => join15(process.env.CODEX_HOME ?? join15(homedir8(), ".codex"), "sessions");
+var codexSessionsDir = () => join17(process.env.CODEX_HOME ?? join17(homedir8(), ".codex"), "sessions");
 var UNAVAILABLE = { status: "unavailable", windows: [], fetchedAt: null, plan: null };
 function windowLabel(minutes) {
   if (minutes === 300) return "Sesi 5 jam";
@@ -31912,7 +32207,7 @@ async function recentRollouts(dir2) {
     return [];
   }
   const stamped = await Promise.all(entries.map(async (rel) => {
-    const full = join15(dir2, rel);
+    const full = join17(dir2, rel);
     try {
       return { full, mtime: (await stat(full)).mtimeMs };
     } catch {
@@ -32040,7 +32335,7 @@ init_src();
 init_src();
 init_config2();
 import { readFileSync as readFileSync12 } from "node:fs";
-import { resolve as resolve15, dirname as dirname12 } from "node:path";
+import { resolve as resolve16, dirname as dirname12 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var UPDATE_COMMAND = "npm i -g hanoman@latest";
 function composeUpdate(x) {
@@ -32066,7 +32361,7 @@ var lastLatest = null;
 var lastStatus = "unavailable";
 function runningVersion() {
   const here = dirname12(fileURLToPath3(import.meta.url));
-  for (const p of [resolve15(here, "build-info.json"), resolve15(here, "../package.json")]) {
+  for (const p of [resolve16(here, "build-info.json"), resolve16(here, "../package.json")]) {
     try {
       const v = JSON.parse(readFileSync12(p, "utf8")).version;
       if (typeof v === "string" && v) return v;
@@ -32417,54 +32712,7 @@ setAcceptedHook((row) => broadcastSyncLog(row));
 init_sync();
 init_sync_client();
 init_conflicts();
-
-// src/services/uploads.ts
-init_config2();
-init_safe_outbound_request();
-init_src2();
-import { mkdir as mkdir2, writeFile, readFile as readFile2, unlink as unlink2 } from "node:fs/promises";
-import { join as join16, resolve as resolve16 } from "node:path";
-function uploadDir() {
-  return resolve16(effectiveStr("HANOMAN_UPLOAD_DIR") ?? join16(resolveHome(), "uploads"));
-}
-async function readUpload(storageKey) {
-  const safe = storageKey.replace(/[/\\]/g, "");
-  return readFile2(join16(uploadDir(), safe));
-}
-async function readUploadOrFetch(storageKey) {
-  const safe = storageKey.replace(/[/\\]/g, "");
-  const target2 = join16(uploadDir(), safe);
-  try {
-    return await readFile2(target2);
-  } catch {
-    const base2 = effectiveStr("SYNC_SERVER_URL");
-    const token = effectiveStr("SYNC_DEVICE_TOKEN");
-    if (!base2 || !token) throw new Error(`lampiran ${safe} tak ada lokal & bukan client sync`);
-    const url2 = new URL(`/api/sync/attachments/${encodeURIComponent(safe)}`, `${base2.replace(/\/$/, "")}/`);
-    const loopback = ["localhost", "127.0.0.1", "::1"].includes(url2.hostname);
-    const res = await safeRequest({
-      url: url2,
-      method: "GET",
-      headers: { authorization: `Bearer ${token}` },
-      allowPrivate: process.env.NODE_ENV !== "production" && loopback,
-      connectMs: 5e3,
-      totalMs: 15e3,
-      maxResponseBytes: 5 * 1024 * 1024
-    });
-    if (res.status < 200 || res.status >= 300) throw new Error(`fetch lampiran hub gagal: ${res.status}`);
-    const buf = res.body;
-    await mkdir2(uploadDir(), { recursive: true, mode: 448 });
-    await writeFile(target2, buf, { mode: 384 });
-    return buf;
-  }
-}
-async function deleteUpload(storageKey) {
-  const safe = storageKey.replace(/[/\\]/g, "");
-  await unlink2(join16(uploadDir(), safe)).catch(() => {
-  });
-}
-
-// src/routes/sync.ts
+init_uploads();
 init_config2();
 var zPush = external_exports.object({
   records: external_exports.array(external_exports.object({
@@ -32615,17 +32863,17 @@ async function session_results_default(app2) {
 // src/services/session-history.ts
 init_db();
 init_pty();
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 
 // src/services/transcript-store.ts
 init_config2();
 init_src2();
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { mkdir as mkdir3, writeFile as writeFile2, readFile as readFile3, unlink as unlink3 } from "node:fs/promises";
-import { join as join17, resolve as resolve17, basename as basename4 } from "node:path";
+import { join as join18, resolve as resolve17, basename as basename4 } from "node:path";
 var MAX_TRANSCRIPT_BYTES = 1024 * 1024;
 function transcriptDir() {
-  return resolve17(effectiveStr("HANOMAN_TRANSCRIPT_DIR") ?? join17(resolveHome(), "transcripts"));
+  return resolve17(effectiveStr("HANOMAN_TRANSCRIPT_DIR") ?? join18(resolveHome(), "transcripts"));
 }
 function clamp(text) {
   const buf = Buffer.from(text, "utf8");
@@ -32642,21 +32890,21 @@ async function saveTranscript(text) {
   const { body, truncated } = clamp(text);
   const dir2 = transcriptDir();
   await mkdir3(dir2, { recursive: true, mode: 448 });
-  const key = `${randomUUID4()}.log`;
-  await writeFile2(join17(dir2, key), body, { encoding: "utf8", mode: 384 });
+  const key = `${randomUUID6()}.log`;
+  await writeFile2(join18(dir2, key), body, { encoding: "utf8", mode: 384 });
   return { key, bytes: Buffer.byteLength(body, "utf8"), truncated };
 }
 async function readTranscript(key) {
   if (!key) return null;
   try {
-    return await readFile3(join17(transcriptDir(), basename4(key)), "utf8");
+    return await readFile3(join18(transcriptDir(), basename4(key)), "utf8");
   } catch {
     return null;
   }
 }
 async function deleteTranscript(key) {
   if (!key) return;
-  await unlink3(join17(transcriptDir(), basename4(key))).catch(() => {
+  await unlink3(join18(transcriptDir(), basename4(key))).catch(() => {
   });
 }
 
@@ -32687,7 +32935,7 @@ async function titleFor(specId) {
 async function beginSession(b) {
   await prisma.sessionHistory.create({
     data: {
-      id: randomUUID5(),
+      id: randomUUID7(),
       sessionId: b.sessionId,
       projectId: b.projectId,
       specId: b.specId ?? null,
@@ -32892,8 +33140,9 @@ init_db();
 
 // src/services/ticket.ts
 init_db();
-import { createHash as createHash7, randomBytes as randomBytes6 } from "node:crypto";
+init_uploads();
 init_src();
+import { createHash as createHash7, randomBytes as randomBytes6 } from "node:crypto";
 function hashAccessKey(key) {
   return createHash7("sha256").update(key).digest("hex");
 }
@@ -32938,12 +33187,13 @@ async function pruneOldTickets(now = Date.now()) {
 // src/services/ticket-intake.ts
 init_db();
 init_notifications();
+init_uploads();
 
 // src/services/upload-pipeline.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { spawn as spawn4 } from "node:child_process";
-import { mkdir as mkdir4, rename as rename2, unlink as unlink4, writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename5, isAbsolute as isAbsolute4, join as join18 } from "node:path";
+import { mkdir as mkdir4, rename as rename3, unlink as unlink4, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename5, isAbsolute as isAbsolute4, join as join19 } from "node:path";
 
 // ../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/Errors.js
 var defaultMessages = "End-Of-Stream";
@@ -40306,7 +40556,8 @@ var dist_default = constructor_default;
 
 // src/services/upload-pipeline.ts
 init_db();
-var UPLOAD_LIMITS = {
+init_uploads();
+var UPLOAD_LIMITS2 = {
   fileBytes: 5 * 1024 * 1024,
   ticketBytes: 10 * 1024 * 1024,
   projectBytes: 250 * 1024 * 1024,
@@ -40358,7 +40609,7 @@ function scannerFromEnv(path2) {
     const timer9 = setTimeout(() => {
       child.kill("SIGKILL");
       reject2(new UploadError("UPLOAD_SCAN", "scanner timeout"));
-    }, UPLOAD_LIMITS.scanMs);
+    }, UPLOAD_LIMITS2.scanMs);
     child.once("error", (error) => {
       clearTimeout(timer9);
       reject2(error);
@@ -40375,9 +40626,9 @@ function safeFilename(input, extension2) {
   return `${stem || "upload"}${extension2}`;
 }
 async function processUpload(input, deps = {}) {
-  if (input.buffer.byteLength === 0 || input.buffer.byteLength > UPLOAD_LIMITS.fileBytes)
+  if (input.buffer.byteLength === 0 || input.buffer.byteLength > UPLOAD_LIMITS2.fileBytes)
     throw new UploadError("UPLOAD_QUOTA", "file quota exceeded");
-  if (input.ticketBytes + input.buffer.byteLength > UPLOAD_LIMITS.ticketBytes)
+  if (input.ticketBytes + input.buffer.byteLength > UPLOAD_LIMITS2.ticketBytes)
     throw new UploadError("UPLOAD_QUOTA", "ticket quota exceeded");
   const detected = await fileTypeFromBuffer(input.buffer);
   if (!detected || !(detected.mime in TYPES) || detected.mime !== input.clientMime)
@@ -40388,14 +40639,14 @@ async function processUpload(input, deps = {}) {
   let height;
   let normalized;
   try {
-    const source = dist_default(input.buffer, { failOn: "error", limitInputPixels: UPLOAD_LIMITS.pixels, sequentialRead: true });
-    const metadata2 = await timeout2(source.metadata(), UPLOAD_LIMITS.decodeMs, "UPLOAD_DECODE");
+    const source = dist_default(input.buffer, { failOn: "error", limitInputPixels: UPLOAD_LIMITS2.pixels, sequentialRead: true });
+    const metadata2 = await timeout2(source.metadata(), UPLOAD_LIMITS2.decodeMs, "UPLOAD_DECODE");
     width = metadata2.width ?? 0;
     height = metadata2.height ?? 0;
-    if (!width || !height || width > UPLOAD_LIMITS.dimension || height > UPLOAD_LIMITS.dimension || width * height > UPLOAD_LIMITS.pixels) throw new UploadError("UPLOAD_PIXELS", "image dimensions exceed policy");
+    if (!width || !height || width > UPLOAD_LIMITS2.dimension || height > UPLOAD_LIMITS2.dimension || width * height > UPLOAD_LIMITS2.pixels) throw new UploadError("UPLOAD_PIXELS", "image dimensions exceed policy");
     normalized = await timeout2(
-      dist_default(input.buffer, { failOn: "error", limitInputPixels: UPLOAD_LIMITS.pixels, sequentialRead: true }).rotate().toFormat(type.format).toBuffer(),
-      UPLOAD_LIMITS.decodeMs,
+      dist_default(input.buffer, { failOn: "error", limitInputPixels: UPLOAD_LIMITS2.pixels, sequentialRead: true }).rotate().toFormat(type.format).toBuffer(),
+      UPLOAD_LIMITS2.decodeMs,
       "UPLOAD_DECODE"
     );
   } catch (error) {
@@ -40403,21 +40654,21 @@ async function processUpload(input, deps = {}) {
     throw new UploadError("UPLOAD_DECODE", "image decode failed");
   }
   const usage2 = await (deps.usage ?? defaultUsage)(input.projectId);
-  if (usage2.project + normalized.byteLength > UPLOAD_LIMITS.projectBytes || usage2.global + normalized.byteLength > UPLOAD_LIMITS.globalBytes)
+  if (usage2.project + normalized.byteLength > UPLOAD_LIMITS2.projectBytes || usage2.global + normalized.byteLength > UPLOAD_LIMITS2.globalBytes)
     throw new UploadError("UPLOAD_QUOTA", "storage quota exceeded");
   const storageDir = deps.storageDir ?? uploadDir();
-  const quarantineDir = join18(storageDir, ".quarantine");
+  const quarantineDir = join19(storageDir, ".quarantine");
   await mkdir4(quarantineDir, { recursive: true, mode: 448 });
   await mkdir4(storageDir, { recursive: true, mode: 448 });
-  const quarantine = join18(quarantineDir, `${randomUUID6()}.upload`);
-  const storageKey = `${randomUUID6()}${type.extension}`;
+  const quarantine = join19(quarantineDir, `${randomUUID8()}.upload`);
+  const storageKey = `${randomUUID8()}${type.extension}`;
   await writeFile3(quarantine, normalized, { mode: 384, flag: "wx" });
   try {
-    await timeout2((deps.scanner ?? scannerFromEnv)(quarantine), UPLOAD_LIMITS.scanMs, "UPLOAD_SCAN");
+    await timeout2((deps.scanner ?? scannerFromEnv)(quarantine), UPLOAD_LIMITS2.scanMs, "UPLOAD_SCAN");
     const finalUsage = await (deps.usage ?? defaultUsage)(input.projectId);
-    if (finalUsage.project + normalized.byteLength > UPLOAD_LIMITS.projectBytes || finalUsage.global + normalized.byteLength > UPLOAD_LIMITS.globalBytes)
+    if (finalUsage.project + normalized.byteLength > UPLOAD_LIMITS2.projectBytes || finalUsage.global + normalized.byteLength > UPLOAD_LIMITS2.globalBytes)
       throw new UploadError("UPLOAD_QUOTA", "storage quota exceeded");
-    await rename2(quarantine, join18(storageDir, storageKey));
+    await rename3(quarantine, join19(storageDir, storageKey));
   } catch (error) {
     await unlink4(quarantine).catch(() => {
     });
@@ -40598,6 +40849,7 @@ async function help_default(app2) {
 
 // src/routes/tickets.ts
 init_db();
+init_uploads();
 
 // src/services/ticket-accept.ts
 init_db();
@@ -41534,10 +41786,10 @@ init_config2();
 init_pty();
 init_session_sandbox();
 import { execFile as execFile10 } from "node:child_process";
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { mkdirSync as mkdirSync9, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 var binFor = (agent) => agent === "codex" ? effectiveStr("HANOMAN_CODEX_BIN") ?? "codex" : effectiveStr("HANOMAN_CLAUDE_BIN") ?? "claude";
 function leadArgv(o) {
   if (o.agent === "codex") {
@@ -41565,11 +41817,11 @@ function leadProcess(prompt, o, env = process.env) {
   const mode = env.HANOMAN_SESSION_SANDBOX ?? (env.NODE_ENV === "production" ? "required" : "off");
   if (mode === "off") return { file, args: directArgs, cwd: o.cwd, cleanup: () => {
   } };
-  const promptDir = join19(tmpdir4(), "hanoman-prompts");
+  const promptDir = join20(tmpdir4(), "hanoman-prompts");
   mkdirSync9(promptDir, { recursive: true, mode: 448 });
-  const promptFile = join19(promptDir, `oneshot-${randomUUID7()}`);
+  const promptFile = join20(promptDir, `oneshot-${randomUUID9()}`);
   writeFileSync5(promptFile, prompt, { flag: "wx", mode: 384 });
-  const workspace = o.cwd ?? join19(tmpdir4(), `hanoman-oneshot-${randomUUID7()}`);
+  const workspace = o.cwd ?? join20(tmpdir4(), `hanoman-oneshot-${randomUUID9()}`);
   if (!o.cwd) mkdirSync9(workspace, { recursive: false, mode: 448 });
   try {
     const argsWithoutPrompt = directArgs.slice(0, -1);
@@ -43358,7 +43610,7 @@ init_db();
 init_src();
 import { readFileSync as readFileSync13 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 var home = () => process.env.HOME || homedir9();
 var readJson2 = (path2) => {
   try {
@@ -43375,7 +43627,7 @@ var serversOf = (node) => {
 var codexServers = () => {
   let text;
   try {
-    text = readFileSync13(join20(home(), ".codex", "config.toml"), "utf8");
+    text = readFileSync13(join21(home(), ".codex", "config.toml"), "utf8");
   } catch {
     return [];
   }
@@ -43388,12 +43640,12 @@ var codexServers = () => {
 };
 function mcpServerNames(repoDir) {
   const names = [];
-  const claudeJson = readJson2(join20(home(), ".claude.json"));
+  const claudeJson = readJson2(join21(home(), ".claude.json"));
   names.push(...serversOf(claudeJson));
   if (repoDir) {
     const projects = claudeJson?.projects;
     if (projects && typeof projects === "object") names.push(...serversOf(projects[repoDir]));
-    names.push(...serversOf(readJson2(join20(repoDir, ".mcp.json"))));
+    names.push(...serversOf(readJson2(join21(repoDir, ".mcp.json"))));
   }
   names.push(...codexServers());
   return [...new Set(names.filter(Boolean))].sort((a, b) => a.localeCompare(b));
@@ -44846,17 +45098,17 @@ init_db();
 
 // src/services/bootstrap.ts
 import { createHash as createHash9, randomBytes as randomBytes9, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
-import { chmod, lstat as lstat2, mkdir as mkdir5, readFile as readFile4, unlink as unlink5, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { chmod, lstat as lstat3, mkdir as mkdir5, readFile as readFile4, unlink as unlink5, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join22 } from "node:path";
 var TTL_MS5 = 15 * 6e4;
 var SETUP_TOKEN_FILE = "setup.token";
 var BootstrapError = class extends Error {
   code = "BOOTSTRAP_PROOF";
 };
-var tokenPath = (home3) => join21(home3, SETUP_TOKEN_FILE);
+var tokenPath = (home3) => join22(home3, SETUP_TOKEN_FILE);
 async function readStored(home3) {
   try {
-    const info = await lstat2(tokenPath(home3));
+    const info = await lstat3(tokenPath(home3));
     if (info.isSymbolicLink() || !info.isFile()) throw new BootstrapError("invalid setup proof");
     const [token, expires] = (await readFile4(tokenPath(home3), "utf8")).trim().split("\n");
     const expiresAt = Date.parse(expires ?? "");
@@ -44869,7 +45121,7 @@ async function readStored(home3) {
 }
 async function ensureSetupToken(home3, now = Date.now()) {
   await mkdir5(home3, { recursive: true, mode: 448 });
-  const homeInfo = await lstat2(home3);
+  const homeInfo = await lstat3(home3);
   if (homeInfo.isSymbolicLink() || !homeInfo.isDirectory()) throw new BootstrapError("invalid setup home");
   await chmod(home3, 448);
   try {
@@ -45063,7 +45315,12 @@ var IDE_SUBS = /* @__PURE__ */ new Set([
   "remotes",
   "compare",
   "archive",
-  "pr-url"
+  "pr-url",
+  // ADR-0121 · operasi berkas Explorer. `rw()` menurunkan read/write DARI METHOD, jadi
+  // POST/PATCH/DELETE menuntut ide:write — capability yang sudah memberi hak menimpa isi
+  // berkas apa pun lewat PUT /file (hindari kelas bug SPEC-405: prefix tanpa lihat method).
+  "entry",
+  "upload"
 ]);
 function capabilityForRoute(method, path2) {
   const read2 = method === "GET" || method === "HEAD";
@@ -45768,7 +46025,7 @@ init_tap();
 // src/services/webhooks/emit.ts
 init_src();
 init_db();
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 function skipped(def2, row) {
   if (!def2.skipWhen || !row) return false;
   return row[def2.skipWhen.field] === def2.skipWhen.equals;
@@ -45834,7 +46091,7 @@ async function emitWebhook(i) {
     const targets = matchingEndpoints(type, projectId);
     if (!targets.length) return;
     const name2 = projectId ? (await prisma.project.findUnique({ where: { id: projectId }, select: { name: true } }))?.name ?? null : null;
-    const env = buildEnvelope(i, name2, (/* @__PURE__ */ new Date()).toISOString(), `evt_${randomUUID8().replace(/-/g, "")}`);
+    const env = buildEnvelope(i, name2, (/* @__PURE__ */ new Date()).toISOString(), `evt_${randomUUID10().replace(/-/g, "")}`);
     if (!env) return;
     await enqueueEnvelope(env, targets);
   } catch (e) {
@@ -46146,14 +46403,14 @@ init_session_sandbox();
 init_src2();
 
 // src/services/secure-home.ts
-import { chmod as chmod2, lstat as lstat3, mkdir as mkdir6 } from "node:fs/promises";
+import { chmod as chmod2, lstat as lstat4, mkdir as mkdir6 } from "node:fs/promises";
 import { isAbsolute as isAbsolute6, resolve as resolve18 } from "node:path";
 var HomePermissionError = class extends Error {
   code = "HOME_SYMLINK";
 };
 async function assertNoSymlink(path2, allowMissing) {
   try {
-    const info = await lstat3(resolve18(path2));
+    const info = await lstat4(resolve18(path2));
     if (info.isSymbolicLink()) throw new HomePermissionError(`symlink ditolak: ${path2}`);
   } catch (error) {
     if (error.code === "ENOENT" && allowMissing) return;
@@ -46184,6 +46441,7 @@ async function secureHanomanHome(opts) {
 
 // src/services/retention.ts
 init_db();
+init_uploads();
 var RETENTION_DAYS = {
   tickets: 90,
   newTickets: 180,
@@ -46298,6 +46556,7 @@ function startRetentionSweep() {
 }
 
 // src/server.ts
+init_uploads();
 var app = buildApp();
 var port = Number(process.env.PORT ?? 8787);
 var host = process.env.HOST ?? "127.0.0.1";