@notis_ai/cli 0.2.0-beta.191.1 → 0.2.0-beta.197.1

package/src/runtime/confined-space-build.js

@@ -0,0 +1,74 @@
+/**
+ * Pinned first build of one Space for a confined local effect
+ * (server/lib/confined_effects/space_build.py).
+ *
+ *   node confined-space-build.js <build-request.json>
+ *
+ * The backend starts this file from a hashed, read-only toolchain under the macOS
+ * sandbox (no network). It reuses the canonical selected-source freeze, manifest,
+ * V4 checks and build receipt (buildSpaceArtifact) and replaces only the build
+ * runner: the canonical Vite command runs with this same node executable and a
+ * rebuilt environment, never PATH npm, a package script or the caller's
+ * environment. It never refreshes the SDK or installs anything.
+ */
+import { spawn } from 'node:child_process';
+import { readFileSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { buildSpaceArtifact } from './space-platform.js';
+
+const CANONICAL_BUILD_SCRIPTS = new Set(['vite build', 'vite build --configLoader runner']);
+const OUTPUT_LIMIT = 32 * 1024;
+
+export function pinnedBuildEnvironment(environment = process.env) {
+  return { PATH: [dirname(process.execPath), '/usr/bin', '/bin'].join(':'), HOME: environment.HOME || '',
+    TMPDIR: environment.TMPDIR || '', LANG: 'C', LC_ALL: 'C', NODE_ENV: 'production' };
+}
+
+export function pinnedViteCommand(projectDir, executable = process.execPath) {
+  const pkg = JSON.parse(readFileSync(join(projectDir, 'package.json'), 'utf8'));
+  const script = String(pkg.scripts?.build || '').trim();
+  if (!CANONICAL_BUILD_SCRIPTS.has(script)) throw new Error('Only the canonical vite build script can run in a confined build.');
+  const vite = realpathSync(join(projectDir, 'node_modules', 'vite', 'bin', 'vite.js'));
+  return [executable, vite, 'build', '--configLoader', 'runner'];
+}
+
+/** buildArtifact runBuild seam: the canonical build, pinned, with bounded captured output. */
+export function runPinnedVite({ projectDir }) {
+  const [command, ...args] = pinnedViteCommand(projectDir);
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, { cwd: projectDir, env: pinnedBuildEnvironment(), stdio: ['ignore', 'pipe', 'pipe'] });
+    let output = '';
+    for (const stream of [child.stdout, child.stderr]) {
+      stream.on('data', chunk => { if (output.length < OUTPUT_LIMIT) output += chunk.toString().slice(0, OUTPUT_LIMIT - output.length); });
+    }
+    child.on('error', rejectPromise);
+    child.on('exit', (code, signal) => {
+      if (code === 0) resolvePromise();
+      else rejectPromise(new Error(`vite build failed (${signal || code})${output.trim() ? `:\n${output.trim()}` : ''}`));
+    });
+  });
+}
+
+export async function runConfinedBuild(request) {
+  if (!request || typeof request.projectDir !== 'string' || typeof request.key !== 'string') {
+    throw new Error('The build request names one workspace and one Space key.');
+  }
+  const result = await buildSpaceArtifact(request.projectDir, request.key, { stdio: 'pipe', refreshSdk: false, runBuild: runPinnedVite });
+  // A summary only: the backend grades the saved build receipt bytes, not this line.
+  const { local_key, kind, name, spec_version } = result.manifest || {};
+  return { status: 'built', key: request.key, receipt_path: result.receiptPath, source_hash: result.sourceHash,
+    manifest: { local_key, kind, name, spec_version } };
+}
+
+async function main(argv) {
+  const request = JSON.parse(readFileSync(argv[2], 'utf8'));
+  try {
+    process.stdout.write(JSON.stringify(await runConfinedBuild(request)) + '\n');
+  } catch (error) {
+    process.stdout.write(JSON.stringify({ status: 'failed', error: String(error?.message || error).slice(0, OUTPUT_LIMIT) }) + '\n');
+    process.exitCode = 1;
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) await main(process.argv);

package/src/runtime/confined-space-verify.js

@@ -0,0 +1,49 @@
+/**
+ * Credential-free canonical verification of one accepted confined build
+ * (server/lib/confined_effects/space_build.py).
+ *
+ *   node confined-space-verify.js <verify-request.json>
+ *
+ * Runs outside the build sandbox so Chromium keeps its own sandbox
+ * (chromiumSandbox: true in the shared renderer pool). The request carries the
+ * capabilities returned by backend source verification and the accepted build's
+ * exact source and artifact digests; anything else refuses before rendering.
+ * Rendering uses only the declared offline fixtures at 390 and 1440 (no live
+ * data, no deployment, no Store publication).
+ */
+import { readFileSync, realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { appFilesDigest } from './app-platform.js';
+import { prepareSpaceRelease } from './space-platform.js';
+import { verifySpaceRelease } from './space-verification.js';
+
+export async function runConfinedVerification(request, { verify = verifySpaceRelease } = {}) {
+  if (!request || typeof request.projectDir !== 'string' || typeof request.key !== 'string'
+    || typeof request.sourceDigest !== 'string' || typeof request.artifactDigest !== 'string'
+    || !request.capabilities || typeof request.capabilities !== 'object') {
+    throw new Error('The verification request names one accepted build and its capabilities.');
+  }
+  const release = await prepareSpaceRelease(request.projectDir, request.key);
+  try {
+    const sourceDigest = appFilesDigest(release.sourceFiles), artifactDigest = appFilesDigest(release.files);
+    if (sourceDigest !== request.sourceDigest || artifactDigest !== request.artifactDigest) {
+      return { status: 'failed', error: 'build_changed', source_digest: sourceDigest, artifact_digest: artifactDigest };
+    }
+    const diagnostic = await verify(release, { capabilities: request.capabilities, timeoutMs: 45_000 });
+    return { status: diagnostic.status === 'passed' ? 'verified' : 'failed', diagnostic };
+  } finally { release.close(); }
+}
+
+async function main(argv) {
+  const request = JSON.parse(readFileSync(argv[2], 'utf8'));
+  try {
+    const result = await runConfinedVerification(request);
+    process.stdout.write(JSON.stringify(result) + '\n');
+    process.exitCode = result.status === 'verified' ? 0 : 3;
+  } catch (error) {
+    process.stdout.write(JSON.stringify({ status: 'failed', error: String(error?.message || error).slice(0, 32 * 1024) }) + '\n');
+    process.exitCode = 1;
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) await main(process.argv);

package/src/runtime/native-record-files.js

@@ -0,0 +1,47 @@
+import { open } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { basename, extname } from 'node:path';
+import { httpRequest } from './transport.js';
+import { usageError } from './errors.js';
+
+const MAX_BYTES = 8 * 1024 * 1024;
+const UUID = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i;
+const MIME = { '.html': 'text/html', '.htm': 'text/html', '.txt': 'text/plain', '.md': 'text/markdown',
+  '.json': 'application/json', '.pdf': 'application/pdf', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp' };
+
+/** Reads a bounded local file, never interprets it and never attaches it to a row. */
+export async function uploadNativeRecordFileWithCliRuntime({ runtime, target, recordKey, schemaRevision, requestId,
+  filePath, name = basename(filePath || ''), contentType = MIME[extname(filePath || '').toLowerCase()] || 'application/octet-stream',
+  signal, request = httpRequest }) {
+  if (!UUID.test(recordKey || '') || !UUID.test(requestId || '') || !Number.isSafeInteger(schemaRevision) || schemaRevision < 0
+    || !target || typeof target !== 'object' || Array.isArray(target) || !filePath) {
+    throw usageError('Choose a local file, native target, record key, schema revision and stable request ID.');
+  }
+  const handle = await open(filePath, 'r');
+  let data;
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size < 1 || stat.size > MAX_BYTES) throw usageError('Choose a regular file up to 8 MB.');
+    const buffer = Buffer.alloc(MAX_BYTES + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const read = await handle.read(buffer, length, buffer.length - length, length);
+      if (!read.bytesRead) break;
+      length += read.bytesRead;
+    }
+    if (!length || length > MAX_BYTES) throw usageError('Choose a file up to 8 MB.');
+    data = buffer.subarray(0, length);
+  } finally { await handle.close(); }
+  const digest = createHash('sha256').update(data).digest('hex');
+  const body = { protocol: 1, target, record_key: recordKey, schema_revision: schemaRevision, request_id: requestId,
+    name, content_type: contentType, base64: data.toString('base64') };
+  // No automatic retry: repeating this command with the same request ID is the
+  // exact immutable intent; a mismatched request fails instead of overwriting.
+  const result = (await request({ runtime, method: 'POST', path: '/portal_native_files/upload', spacesProtocol: 1, body, signal })).payload;
+  if (result?.protocol !== 1 || result.record_key !== recordKey || result.request_id !== requestId
+    || result.sha256 !== digest || result.size_bytes !== data.length || result.file?.name !== name
+    || typeof result.file?.url !== 'string' || !/^https?:\/\//.test(result.file.url) || result.url !== result.file.url) {
+    throw usageError('The file upload is not confirmed. Repeat the same request ID and file bytes.');
+  }
+  return result;
+}

package/src/runtime/retired-sdk-files.js

@@ -0,0 +1,20 @@
+/** Exact canonical files retired by the one-Shadow-runtime cutover.
+ * Modified or additional source is retained for explicit reconciliation. */
+// Host mounting code stays in the canonical SDK and CLI host bundle, not in
+// authored apps' public SDK mirror. It is not a public package export.
+export const HOST_ONLY_SDK_FILES = Object.freeze(['src/presentation.tsx']);
+
+export const RETIRED_SDK_FILES = Object.freeze({
+  "src/presentation.tsx": [
+    "d29022f92e1e96b451b62cc8a561878a1c0cf8a3b4c0419181de7266f8a1b525"
+  ],
+  "src/isolatedHost.tsx": [
+    "7f59049281a9533d39c557ca75635073c2f404f1eb0a528b274323d61db776cd"
+  ],
+  "src/frameProtocol.ts": [
+    "f32337ddb507718be04289a4acf50cf2485698bc716556230f35f06a6f633f19"
+  ],
+  "src/frameIsolation.ts": [
+    "8b57cb38f618eefc4133ae50fbf2b37bbdef5be02e44b39758d8328fb2a59ab6"
+  ]
+});

package/src/runtime/skill-sync/cloud-client.ts

@@ -1,5 +1,7 @@
-import { createSkillBundleBase64 } from './local-scanner';
-import type { AgentTargets, LocalSkill, SyncPullResponse, SyncPushResponse, SyncSettings } from './types';
+import { captureNativeSkillFiles, createSkillBundleBase64 } from './local-scanner';
+import { createHash } from 'node:crypto';
+import { checkedNativeReference } from './native-identity';
+import type { AgentTargets, LocalSkill, NativeSkillReference, SyncPullResponse, SyncPushResponse, SyncSettings } from './types';
 
 type JsonBody = Record<string, unknown> | undefined;
 
@@ -34,7 +36,7 @@ export async function fetchSyncSettings(serverUrl: string, jwt: string): Promise
 
 export async function pullSkills(serverUrl: string, jwt: string): Promise<SyncPullResponse> {
   return requestJson<SyncPullResponse>(`${serverUrl}/portal_skills/sync-pull`, jwt, {
-    body: {},
+    body: { skill_sync_protocol: 2 },
   });
 }
 
@@ -49,11 +51,16 @@ export async function pushChangedSkills(
     skill_md: skill.skillMd,
     source_url: skill.sourceUrl,
     folder_hash: skill.folderHash,
-    bundle_base64: await createSkillBundleBase64(skill),
+    ...(skill.nativeReference ? { bundle_files: await captureNativeSkillFiles(skill) }
+      : { bundle_base64: await createSkillBundleBase64(skill) }),
+    ...(skill.cloudId ? { cloud_id: skill.cloudId } : {}),
+    ...(skill.nativeReference ? { native_reference: skill.nativeReference, display_name: skill.displayName,
+      native_scope: skill.nativeScope } : {}),
   })));
 
   return requestJson<SyncPushResponse>(`${serverUrl}/portal_skills/sync-push`, jwt, {
     body: {
+      skill_sync_protocol: 2,
       skills: payloadSkills,
     },
   });
@@ -75,7 +82,22 @@ export async function updateAgentTargets(
   skillId: string,
   targets: Partial<AgentTargets>,
   expectedUpdatedAt?: string,
+  native?: { reference: NativeSkillReference; settingsRevision: number },
 ): Promise<{ success: boolean; agent_targets: AgentTargets; updated_at?: string }> {
+  if (native) {
+    checkedNativeReference(native.reference, skillId);
+    if (!Number.isSafeInteger(native.settingsRevision) || native.settingsRevision < 0) throw new Error('Refresh native Skill settings before changing assignments.');
+    const payload = { operation: 'update', target: { skill_id: skillId, access_revision: native.reference.access_revision },
+      revision: native.settingsRevision, patch: { agent_targets: Object.fromEntries(Object.entries(targets).sort(([a], [b]) => a.localeCompare(b))) } };
+    const requestId = 'sync-settings-' + createHash('sha256').update(JSON.stringify(payload)).digest('hex');
+    const saved = await requestJson<{ receipt_id: string; skill_id: string; target: { skill_id: string }; settings: { agent_targets: AgentTargets; updated_at: string };
+      current?: { target: { skill_id: string }; settings: { agent_targets: AgentTargets; updated_at: string } } }>(`${serverUrl}/portal_skills/native-settings`, jwt,
+      { body: { ...payload, request_id: requestId } });
+    const current = saved.current || saved;
+    if (saved.skill_id !== skillId || typeof saved.receipt_id !== 'string' || !saved.receipt_id
+        || current.target?.skill_id !== skillId || !current.settings) throw new Error('Native assignment update was not confirmed.');
+    return { success: true, agent_targets: current.settings.agent_targets, updated_at: current.settings.updated_at };
+  }
   return requestJson<{ success: boolean; agent_targets: AgentTargets; updated_at?: string }>(`${serverUrl}/portal_skills/agent-targets`, jwt, {
     method: 'PATCH',
     body: {