@awak-app/simy-cli 0.7.16 → 0.7.18

package/src/execution-capability-contract.js

@@ -1,3 +1,5 @@
+import { PROVIDER_LINKS } from './provider-links.js';
+import { providerDelegationCoverage } from './provider-delegation.js';
 import { localTaskFileCapabilityMetadata } from "./local-task-file-capabilities.js";
 
 export const EXECUTION_CAPABILITY_SCHEMA_VERSION = "execution_capability.v1";
@@ -8,10 +10,11 @@ export function buildExecutionCapabilityContract({
   backendVersions = {},
   providerStatuses,
   authenticated = false,
+  platform = process.platform,
 } = {}) {
   const artifactTypes = supportedArtifactTypes();
   return Object.freeze(
-    ["codex", "claude"].map((provider) =>
+    PROVIDER_LINKS.map((provider) =>
       Object.freeze(
         localExecutionCapability({
           provider,
@@ -20,6 +23,7 @@ export function buildExecutionCapabilityContract({
           authenticated,
           authStatus: providerStatuses?.[provider],
           artifactTypes,
+          platform,
         }),
       ),
     ),
@@ -33,6 +37,7 @@ function localExecutionCapability({
   authenticated,
   authStatus,
   artifactTypes,
+  platform,
 }) {
   const binary = normalizeInspection(provider, inspection, legacyAvailable);
   const providerAuth = authStatus?.state === "ready" ? "ready"
@@ -49,6 +54,7 @@ function localExecutionCapability({
     capability_contract_version: EXECUTION_CAPABILITY_CONTRACT_VERSION,
     execution_target: "local",
     provider,
+    delegation: providerDelegationCoverage([{ provider }])[0],
     // The CLI does not inspect Provider-managed skills, MCP configuration, or
     // connectors. Unknown is materially different from unavailable.
     skills: { status: "unknown", identifiers: [] },
@@ -56,6 +62,14 @@ function localExecutionCapability({
     connectors: [],
     cli_binaries: [binary.public],
     browser_capability: { status: "unknown", modes: [] },
+    device_io: {
+      schema_version: "local_device_io.v1",
+      native_output_staging: provider === "codex" ? "verified_native_cwd" : "provider_permission_flow",
+      local_destination_scopes: provider === "codex" ? ["official_native_writable_roots", "authorized_repository"] : ["authorized_repository"],
+      selected_photos_metadata: platform === "darwin" ? "requires_existing_authorization" : "unavailable",
+      runtime_authorization_required: true,
+      requests_new_permissions: false,
+    },
     supported_input_artifact_types: [...artifactTypes],
     supported_output_artifact_types: [...artifactTypes],
     side_effect_classes: {

package/src/index.js

@@ -68,7 +68,7 @@ if (!configuredWebOrigin) {
 } else if (dispatchArgv[0] === "doctor") {
   const { runDoctor } = await import("./doctor.js");
   process.exitCode = await runDoctor({ webOrigin: configuredWebOrigin, cliVersion: packageInfo.version });
-} else if (dispatchArgv[0] === "delivery" && ["activity", "runtime", "supervise", "diagnose"].includes(dispatchArgv[1])) {
+} else if (dispatchArgv[0] === "delivery" && ["activity", "runtime", "supervise", "diagnose", "consult"].includes(dispatchArgv[1])) {
   // A local observation must not install updates or require a network connection.
   await runCommand();
 } else if (dispatchArgv[0] === "update") {
@@ -160,7 +160,7 @@ Options:
   --port <port>       Bind a specific localhost port
   --host <url>        Connect to a SIMY Web origin (default: ${DEFAULT_WEB_ORIGIN})
   --install-workflows Install or update SIMY Codex/Claude opt-in SQM skills
-  --no-workflow-prompt Skip the daemon startup workflow-installation prompt
+  --no-workflow-prompt Skip initial workflow preparation and background installation of missing sources
   --no-auto-update    Disable update checks and automatic installation
 
 ${autoUpdateHelpText({ installMode, webOrigin: configuredWebOrigin })}
@@ -256,7 +256,7 @@ async function runLocalAgent() {
     webOrigin,
     installMode: updateManager.snapshot().install_mode,
   });
-  stopWorkflowUpdates = startWorkflowUpdates({ enabled: daemon && !updatesDisabled });
+  stopWorkflowUpdates = startWorkflowUpdates({ enabled: daemon && !updatesDisabled, installMissing: !args.has('--no-workflow-prompt') });
   updateManager.start({
     registry: agent.registry,
     restartDaemon: async (targetVersion, installation) => {

package/src/local-photos-read.swift

@@ -0,0 +1,33 @@
+import Foundation
+import Photos
+
+// Bounded PhotoKit metadata only. Never request permission, enumerate the
+// library, read its database, fetch cloud originals, or perform changes.
+func emit(_ value: [String: Any]) {
+    let data = try! JSONSerialization.data(withJSONObject: value, options: [.sortedKeys])
+    print(String(data: data, encoding: .utf8)!)
+}
+let status = PHPhotoLibrary.authorizationStatus(for: .readWrite)
+guard status == .authorized || status == .limited else {
+    emit(["status": "permission_required", "authorization": status.rawValue, "assets": []])
+    exit(0)
+}
+guard CommandLine.arguments.count == 2,
+      let data = CommandLine.arguments[1].data(using: .utf8),
+      let request = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+      let ids = request["asset_ids"] as? [String], !ids.isEmpty, ids.count <= 20 else {
+    emit(["status": "invalid_request", "assets": []]); exit(0)
+}
+let found = PHAsset.fetchAssets(withLocalIdentifiers: ids, options: nil)
+var assets: [[String: Any]] = []
+found.enumerateObjects { asset, _, _ in
+    var value: [String: Any] = ["id": asset.localIdentifier, "pixel_width": asset.pixelWidth,
+                               "pixel_height": asset.pixelHeight, "media_type": asset.mediaType.rawValue]
+    if let date = asset.creationDate { value["created_at"] = ISO8601DateFormatter().string(from: date) }
+    if let location = asset.location {
+        value["latitude"] = location.coordinate.latitude
+        value["longitude"] = location.coordinate.longitude
+    }
+    assets.append(value)
+}
+emit(["status": "ready", "authorization": status.rawValue, "assets": assets])

package/src/local-photos.js

@@ -0,0 +1,47 @@
+import { execFile } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+const fail = code => Object.assign(new Error(code), { code });
+
+export function normalizeLocalPhotoSource(value) {
+  if (value === undefined || value === null) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value) ||
+      Object.keys(value).some(key => !["device_id", "asset_ids"].includes(key)) ||
+      typeof value.device_id !== "string" || !value.device_id ||
+      !Array.isArray(value.asset_ids) || !value.asset_ids.length || value.asset_ids.length > 20 ||
+      value.asset_ids.some(id => typeof id !== "string" || !id || id.length > 256 || /[\u0000-\u001f]/.test(id)) ||
+      new Set(value.asset_ids).size !== value.asset_ids.length) throw fail("local_photos_source_invalid");
+  return { device_id: value.device_id, asset_ids: [...value.asset_ids] };
+}
+
+export async function readPhotoMetadataWithSwift(request, { run = execute } = {}) {
+  // /usr/bin/swift may launch a developer-tools installer on an unprepared Mac.
+  // A read-only preflight fails closed instead; this adapter never installs it.
+  try { await run("/usr/bin/xcode-select", ["-p"], { timeout: 5_000, maxBuffer: 4096 }); }
+  catch { throw fail("local_photos_adapter_unavailable"); }
+  return JSON.parse((await run("/usr/bin/swift", [fileURLToPath(new URL("./local-photos-read.swift", import.meta.url)), JSON.stringify(request)],
+    { timeout: 30_000, maxBuffer: 64 * 1024 })).stdout);
+}
+
+export async function readLocalPhotoSource(value, { deviceId, platform = process.platform,
+  read = readPhotoMetadataWithSwift } = {}) {
+  const source = normalizeLocalPhotoSource(value);
+  if (!source) return null;
+  if (source.device_id !== deviceId) throw fail("local_photos_device_mismatch");
+  if (platform !== "darwin") throw fail("local_photos_adapter_unavailable");
+  const result = await read(source);
+  if (result?.status !== "ready" || ![3, 4].includes(result.authorization)) throw fail("local_photos_existing_permission_required");
+  if (!Array.isArray(result.assets) || result.assets.length !== source.asset_ids.length ||
+      new Set(result.assets.map(asset => asset?.id)).size !== source.asset_ids.length ||
+      result.assets.some(asset => !source.asset_ids.includes(asset?.id))) throw fail("local_photos_selection_unavailable");
+  const assets = result.assets.map(asset => {
+    const record = { id: asset.id };
+    for (const key of ["pixel_width", "pixel_height", "media_type", "latitude", "longitude"]) {
+      if (Number.isFinite(asset[key])) record[key] = asset[key];
+    }
+    if (typeof asset.created_at === "string" && Number.isFinite(Date.parse(asset.created_at))) record.created_at = asset.created_at;
+    return record;
+  });
+  return { schema_version: "local_photos_metadata.v1", device_id: deviceId, assets };
+}

package/src/local-task-attachment-store.js

@@ -249,6 +249,37 @@ export function createLocalTaskAttachmentStore({ root }) {
       return materialized;
     },
 
+    // Only the durable worker passes a prior task from its restored registry.
+    // Ref IDs, bytes and roots remain verified through the existing input contract.
+    async materializeRetained({ refs, deviceId, inputsRoot, retainedTask }) {
+      const values = validateRefs(refs, requireDeviceId(deviceId));
+      const targetRoot = path.resolve(inputsRoot);
+      await mkdir(targetRoot, { recursive: true, mode: 0o700 });
+      const materialized = [];
+      const parentRoot = retainedTask?.inputs_root;
+      if (!parentRoot || !retainedTask.task_root || path.resolve(parentRoot) !== path.join(path.resolve(retainedTask.task_root), 'inputs') ||
+          !(await lstat(parentRoot)).isDirectory() || (await lstat(parentRoot)).isSymbolicLink() ||
+          (await lstat(retainedTask.task_root)).isSymbolicLink())
+        throw storeError('Retained input root is unavailable.', 'local_task_attachment_unsafe_storage', 'reattach_file');
+      for (const ref of values) {
+        const input = retainedTask.attachments?.find(item => item.id === ref.attachment_id && item.name === ref.name &&
+          item.mime_type === ref.mime_type && item.sha256 === ref.sha256 && item.size_bytes === ref.size_bytes);
+        if (!input?.local_path || !retainedTask.inputs_root) throw storeError('Retained input is unavailable.', 'local_task_attachment_ref_not_found', 'reattach_file');
+        await assertManagedRegularFile(input.local_path, retainedTask.inputs_root);
+        const bytes = await readFile(input.local_path);
+        const validated = validateLocalTaskFile({ ...ref, bytes }, { direction: 'input', requireBytes: true });
+        const localPath = path.join(targetRoot, `${ref.attachment_id}-${validated.name}`);
+        try { await writeExclusive(localPath, bytes); }
+        catch (error) {
+          if (error.code !== 'EEXIST') throw error;
+          await assertManagedRegularFile(localPath, targetRoot);
+          validateLocalTaskFile({ ...ref, bytes: await readFile(localPath) }, { direction: 'input', requireBytes: true });
+        }
+        materialized.push({ ...input, local_path: localPath, sha256: validated.sha256, integrity_status: 'verified', executor_handoff_status: 'pending' });
+      }
+      return materialized;
+    },
+
     async cleanup({ refs, deviceId }) {
       const normalizedDeviceId = requireDeviceId(deviceId);
       const values = validateRefs(refs, normalizedDeviceId);

package/src/local-task-destination.js

@@ -0,0 +1,174 @@
+import { constants } from "node:fs";
+import { open, lstat, realpath, link, unlink, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { localTaskArtifact } from "./local-task.js";
+
+function reject(message) {
+  return Object.assign(new Error(message), { code: "local_task_destination_unconfirmed" });
+}
+
+// Paths from cloud/native requests never grant a writable folder by themselves.
+export function normalizeLocalTaskDestination(value) {
+  if (value === undefined || value === null) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value) ||
+      Object.keys(value).some((key) => !["device_id", "repository", "authorized_root", "relative_directory"].includes(key)) ||
+      typeof value.device_id !== "string" || !value.device_id.trim() ||
+      ((typeof value.repository !== "string" || !value.repository.trim()) &&
+       (typeof value.authorized_root !== "string" || !path.isAbsolute(value.authorized_root))) ||
+      (value.repository !== undefined && value.authorized_root !== undefined) ||
+      typeof value.relative_directory !== "string") throw reject("Invalid local save destination.");
+  const relative = value.relative_directory;
+  if (relative && (relative.includes("\\") || /[\u0000-\u001f\u007f:]/.test(relative) ||
+      relative.split("/").some((part) => !part || part === "." || part === ".."))) {
+    throw reject("The save destination must be an existing directory inside the authorized workspace.");
+  }
+  return { device_id: value.device_id, ...(value.authorized_root !== undefined ? { authorized_root: value.authorized_root } : { repository: value.repository }), relative_directory: relative };
+}
+
+export async function resolveLocalTaskDestination(spec, { deviceId, resolveRepository, nativeWritableRoots = [] }) {
+  const value = normalizeLocalTaskDestination(spec?.local_destination);
+  if (!value) return null;
+  if (value.device_id !== deviceId || spec.operation !== "execute" ||
+      spec.permission_mode !== "workspace_write" ||
+      (value.repository && (spec.workspace_mode !== "repository" || value.repository !== spec.repository))) {
+    throw reject("The save destination does not match this device and its authorized workspace.");
+  }
+  const relative = value.relative_directory;
+  let root;
+  if (value.authorized_root) {
+    root = path.resolve(value.authorized_root);
+    if (!nativeWritableRoots.some(allowed => typeof allowed === "string" && path.isAbsolute(allowed) &&
+        (root === path.resolve(allowed) || root.startsWith(path.resolve(allowed).replace(/\/$/, "") + path.sep)))) {
+      throw reject("This folder is outside the existing native session's writable roots. Select it through the original provider's workspace permission flow.");
+    }
+  } else {
+    const repository = await resolveRepository(value.repository);
+    if (!repository?.local_path) throw reject("The save destination is unavailable on this device.");
+    root = path.resolve(repository.local_path);
+  }
+  const destination = { device_id: deviceId, root, directory: path.join(root, relative), relative };
+  try { await assertDirectory(destination); }
+  catch (error) { throw destinationFilesystemError(error); }
+  return destination;
+}
+
+async function assertDirectory(destination) {
+  let current = destination.root;
+  for (const part of ["", ...destination.relative.split("/").filter(Boolean)]) {
+    if (part) current = path.join(current, part);
+    const info = await lstat(current);
+    if (!info.isDirectory() || info.isSymbolicLink() || await realpath(current) !== current) {
+      throw reject("The save destination is no longer a safe local directory.");
+    }
+  }
+}
+
+// Artifact staging is placed inside the already verified native cwd, not the
+// unrelated CLI sandbox. It grants no new root and never relocates the session.
+export async function prepareNativeTaskOutputs(task, nativeCwd, { assertActive = () => {} } = {}) {
+  if (!/^local_task_[A-Za-z0-9_-]+$/.test(task?.id || "") || !path.isAbsolute(nativeCwd || "")) {
+    throw reject("The native output workspace is unavailable.");
+  }
+  const root = await realpath(nativeCwd);
+  const destination = { root, directory: root, relative: "" };
+  await assertDirectory(destination);
+  let current = root;
+  for (const part of [".simy", "local-tasks", task.id, "outputs"]) {
+    await assertActive();
+    current = path.join(current, part);
+    await mkdir(current, { mode: 0o700 }).catch(error => { if (error.code !== "EEXIST") throw error; });
+    const info = await lstat(current);
+    if (!info.isDirectory() || info.isSymbolicLink() || await realpath(current) !== current) {
+      throw reject("The native output workspace is no longer a safe directory.");
+    }
+  }
+  await assertActive();
+  await assertDirectory(destination);
+  task.native_workspace_cwd = root;
+  task.outputs_root = current;
+  task.outputs_root_expected = current;
+  return current;
+}
+
+export async function saveLocalTaskDestination(options) {
+  try { return await saveDestination(options); }
+  catch (error) { throw destinationFilesystemError(error); }
+}
+
+function destinationFilesystemError(error) {
+  if (!error?.syscall) return error;
+  return Object.assign(reject("The save destination is no longer a safe local directory."), { cause: error });
+}
+
+async function saveDestination({ task, destination, assertActive = () => {}, onReceipt = async () => {} }) {
+  if (!destination) return [];
+  const receipts = [];
+  const names = new Set();
+  if (!task.artifacts?.length) throw reject("No verified output is available to save.");
+  for (const ref of task.artifacts) {
+    if (!ref.name || path.basename(ref.name) !== ref.name || ref.name.includes("\\") ||
+        ref.name === "." || ref.name === ".." || names.has(ref.name)) {
+      throw reject("The output files have conflicting or unsafe destination names.");
+    }
+    names.add(ref.name);
+  }
+  for (const ref of task.artifacts) {
+    await assertActive();
+    await assertDirectory(destination);
+    const verified = await localTaskArtifact(task, ref.id);
+    if (!verified) throw reject("The latest output could not be verified before saving.");
+    const source = await open(verified.local_path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    let bytes;
+    try { bytes = await source.readFile(); } finally { await source.close(); }
+    if (bytes.length !== ref.size_bytes || digest(bytes) !== ref.sha256.toLowerCase()) {
+      throw reject("The output changed before saving.");
+    }
+    const localPath = path.join(destination.directory, ref.name);
+    let target;
+    const temporaryPath = path.join(destination.directory, `.simy-save-${randomUUID()}.tmp`);
+    let temporary;
+    try {
+      temporary = await open(temporaryPath, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+      await temporary.writeFile(bytes);
+      await temporary.sync();
+      await assertActive();
+      await assertDirectory(destination);
+      try {
+        // Publish without replacing an existing file. A stopped/failed copy
+        // leaves no truncated destination that could obstruct a safe replay.
+        await link(temporaryPath, localPath);
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+      // Replay confirms identical bytes, but never overwrites another revision.
+      target = await open(localPath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    } finally {
+      await temporary?.close();
+      await unlink(temporaryPath).catch((error) => { if (error.code !== "ENOENT") throw error; });
+    }
+    try {
+      const info = await target.stat();
+      if (!info.isFile()) throw reject("The saved output is not a regular file.");
+      const readback = Buffer.alloc(bytes.length + 1);
+      const { bytesRead } = await target.read(readback, 0, readback.length, 0);
+      if (bytesRead !== bytes.length || digest(readback.subarray(0, bytesRead)) !== ref.sha256.toLowerCase()) {
+        throw reject("The destination contains a different revision; the existing file was preserved.");
+      }
+      await assertDirectory(destination);
+      const visible = await lstat(localPath);
+      if (visible.isSymbolicLink() || visible.dev !== info.dev || visible.ino !== info.ino) {
+        throw reject("The saved path changed during verification.");
+      }
+      // Stop or authorization loss can arrive while filesystem readback awaits.
+      // Preserve any published bytes, but never issue a verified receipt then.
+      await assertActive();
+      receipts.push({ artifact_id: ref.id, sha256: ref.sha256, size_bytes: bytes.length,
+        device_id: destination.device_id, local_path: localPath, verified: true });
+      await onReceipt(receipts.at(-1));
+    } finally { await target?.close(); }
+  }
+  return receipts;
+}
+
+function digest(bytes) { return createHash("sha256").update(bytes).digest("hex"); }