@rubytech/create-maxy-code 0.1.356 → 0.1.358

package/payload/server/server.js

@@ -87,6 +87,7 @@ import {
   resolveClientIp,
   resolveDefaultAgentSlug,
   runAdminUserSelfHeal,
+  runUserProfileReconcile,
   safeJson,
   sanitizeClientCorrId,
   serve,
@@ -106,7 +107,7 @@ import {
   vncLog,
   walkPremiumBundles,
   writeAdminUserAndPerson
-} from "./chunk-25UVZNFA.js";
+} from "./chunk-CXEC5RWB.js";
 import {
   __commonJS,
   __toESM
@@ -7271,6 +7272,8 @@ var SOURCE_ATTR2 = /\bsource="([^"]+)"/;
 var SOURCE_MAP = {
   whatsapp: "whatsapp",
   "whatsapp-channel": "whatsapp",
+  telegram: "telegram",
+  "telegram-channel": "telegram",
   webchat: "webchat",
   "webchat-channel": "webchat"
 };
@@ -7442,7 +7445,12 @@ function parseTranscript(lines, queuedPendingSuppress = /* @__PURE__ */ new Map(
     if (text === null) continue;
     if (CLI_MARKER_PREFIXES2.some((p) => text.startsWith(p))) continue;
     if (HARNESS_LIFECYCLE_PREFIXES.some((p) => text.startsWith(p))) continue;
-    const isChannel = row.isMeta === true && typeof row.origin === "object" && row.origin !== null && row.origin.kind === "channel";
+    const isChannel = row.isMeta === true && typeof row.origin === "object" && row.origin !== null && row.origin.kind === "channel" || // Native Claude Code channels (maxy-lite) journal the delivery twin as a PLAIN
+    // `type:"user"` row whose content is the `<channel source="…">` wrapper, with no
+    // `isMeta`/`origin` stamp. Detect it by the wrapper so it is treated as the
+    // channel twin and consumes the enqueue row's suppression — otherwise the
+    // enqueue row AND this row both render and every channel message doubles.
+    CHANNEL_WRAPPER2.test(text);
     if (isChannel) {
       renderOrSuppressChannelInbound(unwrapChannel(text), ts, out, queuedPendingSuppress);
     } else {
@@ -8529,6 +8537,7 @@ function conflictingBinding(channel) {
 }
 var NO_INDICATORS = {
   activity: null,
+  turnAborted: false,
   permissionMode: null,
   effectivePermissionMode: null,
   model: null,
@@ -8560,6 +8569,7 @@ async function fetchComposerIndicators(sessionId) {
     console.log(`[webchat-session] op=context-usage key=${sessionId} turns=${turnCount} used=${usedTokens ?? "absent"} window=${window} pct=${pct ?? "absent"}`);
     return {
       activity: typeof body.activity === "string" ? body.activity : null,
+      turnAborted: body.turnAborted === true,
       permissionMode: typeof body.permissionMode === "string" ? body.permissionMode : null,
       effectivePermissionMode: typeof body.effectivePermissionMode === "string" ? body.effectivePermissionMode : null,
       model,
@@ -8598,7 +8608,7 @@ async function managerInterrupt(sessionId, trigger) {
   try {
     port2 = requirePortEnv("CLAUDE_SESSION_MANAGER_PORT", { tag: "webchat:interrupt" });
   } catch {
-    return { ok: false, stopped: false, intId: null };
+    return { ok: false, stopped: false, intId: null, deadChild: false };
   }
   try {
     const res = await fetch(`http://127.0.0.1:${port2}/${sessionId}/interrupt`, {
@@ -8607,15 +8617,16 @@ async function managerInterrupt(sessionId, trigger) {
       body: JSON.stringify({ byte: "esc", trigger }),
       signal: AbortSignal.timeout(INTERRUPT_TIMEOUT_MS)
     });
-    if (!res.ok) return { ok: false, stopped: false, intId: null };
+    if (!res.ok) return { ok: false, stopped: false, intId: null, deadChild: false };
     const body = await res.json();
     return {
       ok: true,
       stopped: body.stopped === true,
-      intId: typeof body.intId === "string" ? body.intId : null
+      intId: typeof body.intId === "string" ? body.intId : null,
+      deadChild: body.deadChild === true
     };
   } catch {
-    return { ok: false, stopped: false, intId: null };
+    return { ok: false, stopped: false, intId: null, deadChild: false };
   }
 }
 var MODEL_ID_PATTERN = /^claude-[a-z0-9][a-z0-9.-]*(\[1m\])?$/;
@@ -8918,7 +8929,7 @@ ${note}` : note;
     if (!outcome.ok) {
       return c.json({ error: "interrupt-failed" }, 502);
     }
-    return c.json({ ok: true, stopped: outcome.stopped, intId: outcome.intId }, 200);
+    return c.json({ ok: true, stopped: outcome.stopped, intId: outcome.intId, deadChild: outcome.deadChild }, 200);
   });
   app55.post("/settings", requireAdminSession, async (c) => {
     const body = await c.req.json().catch(() => null);
@@ -13132,18 +13143,10 @@ function dataUploadCeiling() {
   const override = Number(process.env.MAXY_DATA_UPLOAD_MAX_BYTES);
   return Number.isFinite(override) && override > 0 ? override : MAX_DATA_UPLOAD_BYTES;
 }
-app20.post("/upload", requireAdminSession, async (c) => {
-  const cacheKey = c.var.cacheKey;
-  const accountId = getAccountIdForSession(cacheKey);
-  if (!accountId) {
-    console.error(`[data-upload] op=auth-reject reason="no account for session"`);
-    return c.json({ error: "Account not found for session" }, 401);
-  }
+async function resolveUploadTarget(c, accountId, uid) {
   const rawName = c.req.query("filename") ?? "";
   const safeName = basename7(rawName).replace(/[\0/\\]/g, "_");
-  if (!safeName) return c.json({ error: "filename query param required" }, 400);
-  const uid = `${Date.now()}-${randomUUID9().slice(0, 8)}`;
-  const declaredBytes = c.req.header("content-length") ?? "unknown";
+  if (!safeName) return { ok: false, status: 400, error: "filename query param required" };
   const rawRelpath = c.req.query("relpath") ?? "";
   const relpath = rawRelpath !== "" ? rawRelpath : null;
   const token = c.req.query("token") ?? "";
@@ -13151,22 +13154,20 @@ app20.post("/upload", requireAdminSession, async (c) => {
   const mimeType = (c.req.header("content-type") ?? "").split(";")[0].trim();
   if (!SUPPORTED_MIME_TYPES.has(mimeType)) {
     console.error(`[data-upload] op=reject-mime uid=${uid} mime="${mimeType}" token=${token} rel="${relpath ?? ""}"`);
-    return c.json({
-      error: `Unsupported file type: "${mimeType}". Supported: ${[...SUPPORTED_MIME_TYPES].join(", ")}.`
-    }, 422);
+    return { ok: false, status: 422, error: `Unsupported file type: "${mimeType}". Supported: ${[...SUPPORTED_MIME_TYPES].join(", ")}.` };
   }
   const rawDir = c.req.query("path") ?? "";
   const base = resolveOwnAccountWrite(rawDir, accountId, "POST /api/admin/files/upload");
-  if (!base.ok) return c.json({ error: base.error }, base.status);
+  if (!base.ok) return { ok: false, status: base.status, error: base.error };
   const relDir = relpath ? dirname6(relpath) : ".";
   const destRel = relDir === "." ? base.relative : join25(base.relative, relDir);
   if (crossesForeignAccountPartition(destRel, accountId)) {
     console.error(`[data] account-scope-blocked endpoint="POST /api/admin/files/upload" path="${destRel}" account=${accountId.slice(0, 8)}\u2026`);
-    return c.json({ error: "Not found" }, 404);
+    return { ok: false, status: 404, error: "Not found" };
   }
   if (!isWithinOwnAccountPartition(destRel, accountId)) {
     console.error(`[data] write-scope-blocked endpoint="POST /api/admin/files/upload" path="${destRel}" account=${accountId.slice(0, 8)}\u2026`);
-    return c.json({ error: "Path is outside your account folder" }, 403);
+    return { ok: false, status: 403, error: "Path is outside your account folder" };
   }
   const destDir = relDir === "." ? base.absolute : resolve21(base.absolute, relDir);
   const destPath = resolve21(destDir, finalName);
@@ -13175,14 +13176,40 @@ app20.post("/upload", requireAdminSession, async (c) => {
     if (firstCreated) console.error(`[data-upload] op=mkdir uid=${uid} token=${token} dir="${destRel}"`);
   } else {
     const info = await stat4(destDir).catch(() => null);
-    if (!info || !info.isDirectory()) return c.json({ error: "Upload destination is not a directory" }, 400);
+    if (!info || !info.isDirectory()) return { ok: false, status: 400, error: "Upload destination is not a directory" };
   }
   const dataRootReal = realpathSync4(DATA_ROOT);
   const destDirReal = realpathSync4(destDir);
   if (destDirReal !== dataRootReal && !destDirReal.startsWith(dataRootReal + sep6)) {
     console.error(`[data-upload] op=path-traversal-blocked uid=${uid} requested="${destRel}" resolved="${destDirReal}"`);
-    return c.json({ error: "Upload destination escapes DATA_ROOT" }, 403);
+    return { ok: false, status: 403, error: "Upload destination escapes DATA_ROOT" };
+  }
+  return { ok: true, destDir, destPath, destRel, finalName, mimeType, relpath, token };
+}
+async function logUploadsTmpCensus(accountId) {
+  const tmpDir = resolve21(DATA_ROOT, "accounts", accountId, UPLOAD_TMP_DIR);
+  let live = 0;
+  try {
+    live = (await readdir3(tmpDir)).length;
+  } catch {
   }
+  console.error(`[uploads-tmp-census] dir=${accountId} live=${live}`);
+}
+app20.post("/upload", requireAdminSession, async (c) => {
+  const cacheKey = c.var.cacheKey;
+  const accountId = getAccountIdForSession(cacheKey);
+  if (!accountId) {
+    console.error(`[data-upload] op=auth-reject reason="no account for session"`);
+    return c.json({ error: "Account not found for session" }, 401);
+  }
+  if (c.req.query("uploadId") !== void 0) {
+    return handleChunkUpload(c, accountId);
+  }
+  const uid = `${Date.now()}-${randomUUID9().slice(0, 8)}`;
+  const declaredBytes = c.req.header("content-length") ?? "unknown";
+  const target = await resolveUploadTarget(c, accountId, uid);
+  if (!target.ok) return c.json({ error: target.error }, target.status);
+  const { destPath, destRel, finalName, mimeType, relpath, token } = target;
   const body = c.req.raw.body;
   if (!body) return c.json({ error: "Empty request body" }, 400);
   console.error(`[data-upload] op=request uid=${uid} account=${accountId} dir="${destRel}" token=${token} rel="${relpath ?? ""}" declaredBytes=${declaredBytes}`);
@@ -13263,6 +13290,7 @@ app20.post("/upload", requireAdminSession, async (c) => {
   void indexFile(accountId, relativeDest).catch((err) => {
     console.error(`[data-upload] op=index-failed uid=${uid} dest="${relativeDest}" err="${err instanceof Error ? err.message : String(err)}"`);
   });
+  void logUploadsTmpCensus(accountId);
   return c.json({
     path: relativeDest,
     filename: finalName,
@@ -13270,6 +13298,178 @@ app20.post("/upload", requireAdminSession, async (c) => {
     mimeType
   });
 });
+var chunkUploads = /* @__PURE__ */ new Map();
+async function discardChunkUpload(uploadId, state) {
+  chunkUploads.delete(uploadId);
+  await new Promise((res) => {
+    if (state.out.closed) return res();
+    state.out.once("close", () => res());
+    state.out.destroy();
+  });
+  await unlink2(state.tmpPath).catch(() => {
+  });
+  const tempRemoved = !existsSync23(state.tmpPath);
+  console.error(`[data-upload] op=cleanup uid=${uploadId} tempRemoved=${tempRemoved}`);
+}
+async function writeChunkBody(body, out, alreadyReceived, ceiling) {
+  const reader = body.getReader();
+  let written = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    if (alreadyReceived + written + value.byteLength > ceiling) {
+      written += value.byteLength;
+      await reader.cancel().catch(() => {
+      });
+      return { written, overCeiling: true };
+    }
+    written += value.byteLength;
+    if (!out.write(value)) {
+      await new Promise((res, rej) => {
+        const onDrain = () => {
+          out.off("error", onErr);
+          res();
+        };
+        const onErr = (e) => {
+          out.off("drain", onDrain);
+          rej(e);
+        };
+        out.once("drain", onDrain);
+        out.once("error", onErr);
+      });
+    }
+  }
+  return { written, overCeiling: false };
+}
+async function handleChunkUpload(c, accountId) {
+  const uploadId = c.req.query("uploadId") ?? "";
+  const seq = Number(c.req.query("seq"));
+  const total = Number(c.req.query("total"));
+  if (!uploadId || !Number.isInteger(seq) || !Number.isInteger(total) || seq < 0 || total < 1 || seq >= total) {
+    return c.json({ error: "Invalid chunk parameters" }, 400);
+  }
+  const body = c.req.raw.body;
+  if (!body) return c.json({ error: "Empty request body" }, 400);
+  const ceiling = dataUploadCeiling();
+  if (seq === 0) {
+    const existing = chunkUploads.get(uploadId);
+    if (existing) {
+      if (existing.accountId !== accountId) {
+        console.error(`[data-upload] op=chunk-gap uid=${uploadId} reason=foreign-seq0`);
+        return c.json({ error: "Chunk out of order \u2014 restart the upload" }, 409);
+      }
+      await discardChunkUpload(uploadId, existing);
+    }
+    const target = await resolveUploadTarget(c, accountId, uploadId);
+    if (!target.ok) return c.json({ error: target.error }, target.status);
+    const tmpDir = resolve21(DATA_ROOT, "accounts", accountId, UPLOAD_TMP_DIR);
+    await mkdir3(tmpDir, { recursive: true });
+    const tmpPath = resolve21(tmpDir, `${uploadId}.part`);
+    const out = createWriteStream2(tmpPath);
+    const state2 = {
+      accountId,
+      destPath: target.destPath,
+      destRel: target.destRel,
+      finalName: target.finalName,
+      tmpPath,
+      out,
+      writeError: null,
+      busy: false,
+      received: 0,
+      nextSeq: 0,
+      total,
+      mimeType: target.mimeType,
+      token: target.token,
+      relpath: target.relpath,
+      t0: Date.now(),
+      lastActivityMs: Date.now()
+    };
+    out.on("error", (e) => {
+      state2.writeError = e;
+    });
+    chunkUploads.set(uploadId, state2);
+    console.error(`[data-upload] op=request uid=${uploadId} account=${accountId} dir="${target.destRel}" token=${target.token} rel="${target.relpath ?? ""}" declaredBytes=chunked total=${total}`);
+    return acceptChunk(c, uploadId, state2, seq, body, ceiling);
+  }
+  const state = chunkUploads.get(uploadId);
+  if (!state || state.accountId !== accountId || seq !== state.nextSeq) {
+    console.error(`[data-upload] op=chunk-gap uid=${uploadId} expected=${state ? state.nextSeq : "none"} got=${seq}`);
+    if (state && state.accountId === accountId) await discardChunkUpload(uploadId, state);
+    return c.json({ error: "Chunk out of order \u2014 restart the upload" }, 409);
+  }
+  return acceptChunk(c, uploadId, state, seq, body, ceiling);
+}
+async function acceptChunk(c, uploadId, state, seq, body, ceiling) {
+  if (state.busy) {
+    console.error(`[data-upload] op=chunk-gap uid=${uploadId} expected=${state.nextSeq} got=${seq} reason=busy`);
+    return c.json({ error: "Chunk out of order \u2014 restart the upload" }, 409);
+  }
+  state.busy = true;
+  try {
+    try {
+      const { written, overCeiling } = await writeChunkBody(body, state.out, state.received, ceiling);
+      if (state.writeError) throw state.writeError;
+      state.received += written;
+      if (overCeiling || state.received > ceiling) {
+        console.error(`[data-upload] op=reject-size uid=${uploadId} received=${state.received} ceiling=${ceiling}`);
+        await discardChunkUpload(uploadId, state);
+        return c.json({ error: `File exceeds the ${Math.floor(ceiling / 1024 / 1024)} MB limit.` }, 413);
+      }
+      state.nextSeq = seq + 1;
+      state.lastActivityMs = Date.now();
+      console.error(`[data-upload] op=chunk uid=${uploadId} token=${state.token} seq=${seq}/${state.total} bytes=${written} received=${state.received}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[data-upload] op=error uid=${uploadId} err="${message}" token=${state.token} rel="${state.relpath ?? ""}"`);
+      await discardChunkUpload(uploadId, state);
+      return c.json({ error: message }, 500);
+    }
+    if (seq < state.total - 1) {
+      return c.json({ ok: true, received: state.received, seq, total: state.total });
+    }
+    chunkUploads.delete(uploadId);
+    try {
+      await new Promise((res, rej) => {
+        state.out.once("error", rej);
+        state.out.end(() => res());
+      });
+      await rename(state.tmpPath, state.destPath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[data-upload] op=error uid=${uploadId} err="${message}" token=${state.token} rel="${state.relpath ?? ""}"`);
+      await unlink2(state.tmpPath).catch(() => {
+      });
+      return c.json({ error: message }, 500);
+    }
+    const relativeDest = `${state.destRel}/${state.finalName}`;
+    console.error(`[data-upload] op=assemble uid=${uploadId} chunks=${state.total} totalBytes=${state.received} path="${relativeDest}" token=${state.token} ms=${Date.now() - state.t0}`);
+    void indexFile(state.accountId, relativeDest).catch((err) => {
+      console.error(`[data-upload] op=index-failed uid=${uploadId} dest="${relativeDest}" err="${err instanceof Error ? err.message : String(err)}"`);
+    });
+    void logUploadsTmpCensus(state.accountId);
+    return c.json({
+      path: relativeDest,
+      filename: state.finalName,
+      sizeBytes: state.received,
+      mimeType: state.mimeType
+    });
+  } finally {
+    state.busy = false;
+  }
+}
+async function evictStaleChunkUploads(ttlMs) {
+  const now = Date.now();
+  let evicted = 0;
+  for (const [uploadId, state] of [...chunkUploads.entries()]) {
+    if (now - state.lastActivityMs > ttlMs) {
+      console.error(`[data-upload] op=cleanup uid=${uploadId} reason=idle-ttl`);
+      await discardChunkUpload(uploadId, state);
+      evicted++;
+    }
+  }
+  return evicted;
+}
 async function sweepStaleUploadTemps() {
   const accountsRoot = resolve21(DATA_ROOT, "accounts");
   let accounts;
@@ -16232,6 +16432,16 @@ function managerBase2() {
   const port2 = requirePortEnv("CLAUDE_SESSION_MANAGER_PORT", { tag: "channel-pty-bridge:manager-client" });
   return `http://127.0.0.1:${port2}`;
 }
+async function connectorAuthLogin(opts) {
+  const res = await fetch(`${managerBase2()}/connector-auth-login`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(opts)
+  });
+  const body = await res.json().catch(() => null);
+  if (!res.ok || !body) return { error: `manager-${res.status}` };
+  return body;
+}
 async function managerSpawn(opts) {
   const auth = await ensureAuth();
   if (auth.status === "dead" || auth.status === "missing") {
@@ -19951,6 +20161,19 @@ function createWebchatChannelRoutes(deps) {
     deps.onReply?.(key, text);
     return c.json({ ok: true });
   });
+  app55.post("/webchat-channel/connector-auth", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    const key = body?.key;
+    const sessionId = body?.sessionId;
+    const name = body?.name;
+    const completed = body?.completed === true;
+    if (typeof key !== "string" || typeof sessionId !== "string" || typeof name !== "string" || !name.trim()) {
+      return c.json({ error: "key, sessionId and name required" }, 400);
+    }
+    if (!deps.onConnectorAuth) return c.json({ error: "connector-auth-unavailable" }, 503);
+    const result = await deps.onConnectorAuth({ key, sessionId, name, completed });
+    return c.json(result);
+  });
   app55.post("/webchat-channel/ready", async (c) => {
     const body = await c.req.json().catch(() => null);
     const key = body?.key;
@@ -20230,7 +20453,8 @@ var WebchatGateway = class _WebchatGateway {
         }
       },
       onReply: (key, text) => this.handleReply(key, text),
-      awaitPermissionVerdict: (p) => this.awaitPermissionVerdict(p, permissionVerdictTtlMs())
+      awaitPermissionVerdict: (p) => this.awaitPermissionVerdict(p, permissionVerdictTtlMs()),
+      onConnectorAuth: ({ sessionId, name, completed }) => connectorAuthLogin({ sessionId, name, completed })
     });
   }
   /** Run one reconciliation pass: log every terminal delivery event the sweep
@@ -22800,6 +23024,7 @@ async function runAdminUserReconcileTick() {
       return;
     }
     await runAdminUserSelfHeal({ userId, accountId: account.accountId });
+    await runUserProfileReconcile();
   } catch (err) {
     console.error(`[adminuser-self-heal] rejected: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -22845,6 +23070,10 @@ void migrateUploads().catch((err) => console.error(`[uploads-migrate] failed err
   });
 });
 void sweepStaleUploadTemps().catch((err) => console.error(`[data-upload] op=sweep-failed err="${err instanceof Error ? err.message : String(err)}"`));
+var CHUNK_IDLE_TTL_MS = 30 * 60 * 1e3;
+setInterval(() => {
+  void evictStaleChunkUploads(CHUNK_IDLE_TTL_MS).catch((err) => console.error(`[data-upload] op=evict-failed err="${err instanceof Error ? err.message : String(err)}"`));
+}, 10 * 60 * 1e3).unref();
 void migrateAdminWebchatSidecars().catch((err) => console.error(`[sidecar-backfill] failed err="${err instanceof Error ? err.message : String(err)}"`));
 try {
   const accounts = enumerateValidAccountIds(getAccountsDirFromEnv());

package/payload/server/userprofile-reconcile-GLGKDVQQ.js

@@ -0,0 +1,48 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import "./chunk-PFF6I7KP.js";
+
+// app/lib/userprofile-reconcile.ts
+function toNum(raw) {
+  if (typeof raw === "number") return raw;
+  if (raw && typeof raw.toNumber === "function") {
+    return raw.toNumber();
+  }
+  return 0;
+}
+async function reconcileUserProfiles(args) {
+  const { driver } = args;
+  const serverTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const session = driver.session();
+  try {
+    const provResult = await session.run(
+      `MATCH (au:AdminUser)
+       WHERE au.accountId IS NOT NULL AND au.userId IS NOT NULL
+         AND NOT (au)-[:HAS_PROFILE]->(:UserProfile)
+       MERGE (au)-[:HAS_PROFILE]->(up:UserProfile {accountId: au.accountId, userId: au.userId})
+       ON CREATE SET
+         up.createdAt = $now,
+         up.updatedAt = $now,
+         up.profileVersion = 0,
+         up.scope = 'admin',
+         up.timezone = $serverTimezone
+       RETURN count(up) AS provisioned`,
+      { now, serverTimezone }
+    );
+    const provisioned = toNum(provResult.records[0]?.get("provisioned"));
+    console.error(`[userprofile-reconcile] provisioned=${provisioned}`);
+    const residualResult = await session.run(
+      `MATCH (au:AdminUser)
+       WHERE NOT (au)-[:HAS_PROFILE]->(:UserProfile)
+       RETURN count(au) AS residual`
+    );
+    const residual = toNum(residualResult.records[0]?.get("residual"));
+    console.error(`[userprofile-reconcile] residual=${residual}`);
+    return { provisioned, residual };
+  } finally {
+    await session.close();
+  }
+}
+export {
+  reconcileUserProfiles
+};