@xuda.io/ai_module 1.1.5660 → 1.1.5661

package/index.mjs

@@ -141,7 +141,7 @@ const xucode_verify = await import('./xucode_verify.mjs');
 // Where the provider credential lives. The machine gets a run token; this box keeps the key.
 const xucode_proxy = await import('./xucode_proxy.mjs');
 // The last gate of that loop: is the app still actually running. See xucode_preview.mjs.
-const { create_preview: _create_xucode_preview } = await import('./xucode_preview.mjs');
+const { create_preview: _create_xucode_preview, preview_host: xucode_preview_host } = await import('./xucode_preview.mjs');
 const xucode_preview = _create_xucode_preview({});
 const xucode_runtime = _create_xucode_runtime({ run_process });
 
@@ -3904,6 +3904,54 @@ const xucode_prepare_engine = async function ({ uid, profile_id, engine, model,
   return { code: 1, launch, has_key: !!api_key, proxied: false, byok: key_ref.has_key };
 };
 
+// What the Code tab shows for a project's preview (plan 7).
+//
+// Deliberately does NOT wake a sleeping machine. A panel that polls would otherwise keep every
+// machine awake forever, which is the opposite of what sleep is for and would bill the customer
+// for a screen they left open. So a sleeping machine reports 'asleep' with its URL, and the next
+// run wakes it in the normal way.
+//
+// The URL is derived rather than stored, so it is always the one the router will resolve; there is
+// no second copy to drift. `listening` is the only part that needs the machine, and it is asked
+// for only when the machine is already up.
+export const xucode_preview_status = async function (req) {
+  const { uid, profile_id, app_id } = req || {};
+  try {
+    if (!app_id) return { code: -1, data: 'app_id is required' };
+    const host = xucode_preview_host(app_id);
+    const port = xucode_preview.preview_port(app_id);
+    const base = { url: host ? `https://${host}/` : null, port };
+
+    // `no_wake`: a status read must never resume a machine, or a panel left open keeps every
+    // machine awake and bills the customer for a screen nobody is watching.
+    const machine = await deploy_ms.xucode_machine_for({ uid, app_id, no_wake: true }).catch(() => null);
+    if (!machine || machine.code < 0) {
+      // Asleep, quarantined and "no machine at all" are three different answers, and the customer
+      // deserves the right one: only the middle is a fault.
+      const state = machine?.asleep ? 'asleep' : machine?.quarantined ? 'quarantined' : 'unavailable';
+      return { code: 1, data: { ...base, state, why: String(machine?.data || 'this project has no machine yet') } };
+    }
+
+    // The machine is up (xucode_machine_for refuses a quarantined one and wakes nothing that is
+    // merely asleep beyond its own resume path), so it is safe to ask whether anything is serving.
+    const dir = path.join(_conf.xucode?.projects_root || '/srv/xucode', String(app_id));
+    let listening = false;
+    try {
+      const workspace = await xucode_runtime.acquire({ uid, project_id: app_id, app_id, dir });
+      const status = await xucode_preview.status(workspace, app_id, port);
+      listening = status?.listening === true;
+      await workspace.release().catch(() => {});
+    } catch (e) {
+      return { code: 1, data: { ...base, state: 'unavailable', why: 'Xuda could not reach this project just now.' } };
+    }
+
+    return { code: 1, data: { ...base, state: listening ? 'running' : 'stopped' } };
+  } catch (err) {
+    console.error(`[xucode] preview status failed: ${err?.message || err}`);
+    return { code: -1, data: 'could not read the preview' };
+  }
+};
+
 export const xucode_engine_list = async function () {
   return { code: 1, data: { engines: xucode_engines.list_engines() } };
 };
@@ -4192,7 +4240,7 @@ export const xucode_run = async function (req) {
       // them. Only ever reached with `tracker.enforce` on, so the default remains observe.
       if (ret.record.enforced === true) {
         try {
-          const q = await deploy_msa.xucode_quarantine({ app_id, reasons: ret.record.reasons || [], run_id });
+          const q = await deploy_msa.xucode_quarantine({ app_id, uid, reasons: ret.record.reasons || [], run_id });
           if (q?.code < 0) console.error(`[xucode] quarantine failed for ${app_id}: ${q.data}`);
         } catch (e) {
           console.error(`[xucode] quarantine threw for ${app_id}: ${e?.message || e}`);
@@ -4204,8 +4252,13 @@ export const xucode_run = async function (req) {
     // stopped: touching it would reset the idle clock on a machine we want left alone.
     if (!ret.killed && ret.record?.enforced !== true) {
       try {
-        await deploy_msa.xucode_touch({ app_id });
-      } catch (e) {}
+        // `uid` matters here: `app_id` is the PROJECT, and touch operates on the MACHINE. Passing
+        // the project alone is why this silently did nothing on every run until now.
+        const touched = await deploy_msa.xucode_touch({ app_id, uid });
+        if (touched?.code < 0) console.warn(`[xucode] could not refresh activity for ${app_id}: ${touched.data}`);
+      } catch (e) {
+        console.warn(`[xucode] touch threw for ${app_id}: ${e?.message || e}`);
+      }
     }
 
     return ret;

package/index_ms.mjs

@@ -81,6 +81,10 @@ export const xucode_key_delete = async function (...args) {
   return await broker.send_to_queue("xucode_key_delete", ...args);
 };
 
+export const xucode_preview_status = async function (...args) {
+  return await broker.send_to_queue("xucode_preview_status", ...args);
+};
+
 export const xucode_engine_list = async function (...args) {
   return await broker.send_to_queue("xucode_engine_list", ...args);
 };

package/index_msa.mjs

@@ -81,6 +81,10 @@ export const xucode_key_delete =  function (...args) {
    broker.send_to_queue_async("xucode_key_delete", ...args);
 };
 
+export const xucode_preview_status =  function (...args) {
+   broker.send_to_queue_async("xucode_preview_status", ...args);
+};
+
 export const xucode_engine_list =  function (...args) {
    broker.send_to_queue_async("xucode_engine_list", ...args);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/ai_module",
-  "version": "1.1.5660",
+  "version": "1.1.5661",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",

package/xucode_preview.mjs

@@ -39,6 +39,44 @@ export const preview_port = function (project_id, base = num('base_port', 4300),
   return base + (h % span);
 };
 
+// The public hostname a project's preview answers on, and the reason it is a TEMPLATE.
+//
+// The obvious scheme is `<project>.preview.xuda.app`, which is what was asked for and what reads
+// best. It does not work today, and the reason is worth writing down so nobody rediscovers it:
+// Cloudflare's certificate for this zone covers `xuda.app` and `*.xuda.app`, and a DNS wildcard
+// matches exactly ONE label. So `<project>.preview.xuda.app` fails the TLS handshake before any
+// routing happens. Verified against the live edge: the single-label form answers, the two-label
+// form dies with a handshake failure. Issuing a second-level wildcard needs Cloudflare's Advanced
+// Certificate Manager, which is a paid per-zone add-on.
+//
+// So the default is a single label that the existing certificate already covers, and the scheme
+// lives in config: the day that certificate exists, this becomes one config edit rather than a
+// change to the router, the runtime and the tests.
+//
+// The project id is sanitized because it becomes a DNS label, and a label may hold only letters,
+// digits and hyphens.
+export const preview_host = function (project_id) {
+  const template = preview_conf().host_template;
+  if (!template) return null;
+  const label = String(project_id || '').replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+  if (!label) return null;
+  return template.replace('{project}', label).toLowerCase();
+};
+
+// The inverse, for the router: given a hostname, which project is this a preview of. Returns null
+// unless the host matches the configured template exactly, so a preview host can never be confused
+// with the vps_web index, which resolves on the first label alone and would otherwise collide.
+export const preview_project_from_host = function (hostname) {
+  const template = preview_conf().host_template;
+  if (!template || !hostname) return null;
+  const host = String(hostname).split(':')[0].trim().toLowerCase();
+  const [prefix, suffix] = template.toLowerCase().split('{project}');
+  if (!host.startsWith(prefix) || !host.endsWith(suffix)) return null;
+  const label = host.slice(prefix.length, host.length - suffix.length);
+  // One label only. Without this, `a.b-preview.xuda.app` would resolve as project `a.b`.
+  return /^[a-z0-9]+$/.test(label) ? label : null;
+};
+
 // What starts this project. `dev` first because that is the one with hot reload, which is the
 // difference between a preview and a screenshot.
 export const detect_dev_command = function (manifest, package_manager = 'npm') {

package/xucode_vm.mjs

@@ -37,6 +37,11 @@ export const shq = (value) => `'${String(value).replace(/'/g, `'\\''`)}'`;
 
 const vm_conf = () => global._conf.xucode?.vm || {};
 
+// The preview hostname scheme lives with the preview code, not here: this file only needs to hand
+// back a URL, and duplicating the template is how the router and the runtime end up disagreeing
+// about what a preview is called.
+const { preview_host: _preview_host } = await import('./xucode_preview.mjs');
+
 export const create_vm_substrate = function ({ pve_request, resolve_machine, delay = (ms) => new Promise((r) => setTimeout(r, ms)), now = () => Date.now() }) {
   if (typeof pve_request !== 'function') throw new Error('create_vm_substrate needs pve_request');
   if (typeof resolve_machine !== 'function') throw new Error('create_vm_substrate needs resolve_machine');
@@ -249,9 +254,8 @@ export const create_vm_substrate = function ({ pve_request, resolve_machine, del
         // the one port that is ever reachable, and it goes through the platform's existing web
         // route for the app rather than a second proxy invented here.
         async expose_port(port) {
-          const base = global._conf.xucode?.preview_domain;
-          if (!base) return null;
-          return { url: `https://${String(project_id).replace(/[^a-zA-Z0-9]/g, '')}.${base}`, port };
+          const host = _preview_host(project_id);
+          return host ? { url: `https://${host}/`, port } : null;
         },
 
         // The machine persists between runs, which is the whole point of the paid tiers, so