agentlas 0.7.0 → 0.9.2

package/test/cloud-cas-client.cjs

@@ -1,333 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const assert = require("node:assert/strict");
-const fs = require("node:fs");
-const http = require("node:http");
-const os = require("node:os");
-const path = require("node:path");
-
-const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentlas-cloud-cas-client-"));
-process.env.AGENTLAS_USER_DATA_DIR = path.join(tempDir, "user-data");
-process.env.AGENTLAS_SESSION = "cas-owner-session";
-
-const {
-  deleteCloudAgentCli,
-  packageCloudAgentCli,
-  readCloudAssetStateCli,
-} = require("../engine/agentlas.cjs");
-
-function writePrivateAgent(root, title = "CAS Agent") {
-  fs.mkdirSync(root, { recursive: true });
-  fs.writeFileSync(path.join(root, "AGENTS.md"), `# ${title}\n\nCAS_TEST_ENTRY\n`, "utf8");
-}
-
-function writePublicAgent(root, title = "CAS Public Agent") {
-  writePrivateAgent(root, title);
-  fs.mkdirSync(path.join(root, ".agentlas"), { recursive: true });
-  fs.writeFileSync(path.join(root, ".agentlas", "routing-card.json"), JSON.stringify({
-    schemaVersion: "routing-card/2.0",
-    id: title.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
-    type: "agent",
-    name: title,
-    summary: "Exercises conditional multi-host Cloud writes.",
-    capabilities: ["cloud_cas_testing"],
-    routing_status: "routing_ready",
-  }, null, 2) + "\n");
-}
-
-function listen(server) {
-  return new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => resolve(server.address()));
-  });
-}
-
-function close(server) {
-  return new Promise((resolve) => server.close(resolve));
-}
-
-function descriptorFor(body, sequence, cloudId) {
-  const scope = body.visibility === "marketplace" ? "hub-public" : "owner-private";
-  const revision = `rev-${sequence}-${body.manifest.packageHash.slice(0, 16)}`;
-  return {
-    cloudId,
-    slug: body.manifest.slug,
-    scope,
-    packageHash: body.manifest.packageHash,
-    packageHashVersion: body.manifest.packageHashVersion,
-    revision,
-    etag: `"${revision}"`,
-    updatedAt: new Date().toISOString(),
-  };
-}
-
-function sendJson(response, status, body, headers = {}) {
-  response.writeHead(status, { "content-type": "application/json", "cache-control": "no-store", ...headers });
-  response.end(JSON.stringify(body));
-}
-
-(async () => {
-  const assets = new Map();
-  const requests = [];
-  let sequence = 0;
-  let cloudSequence = 0;
-  const server = http.createServer((request, response) => {
-    const url = new URL(request.url, "http://127.0.0.1");
-    const chunks = [];
-    request.on("data", (chunk) => chunks.push(chunk));
-    request.on("end", () => {
-      const body = chunks.length ? JSON.parse(Buffer.concat(chunks).toString("utf8")) : null;
-      requests.push({ method: request.method, url, headers: { ...request.headers }, body });
-      if (request.method === "POST") {
-        const scope = body.visibility === "marketplace" ? "hub-public" : "owner-private";
-        const key = `${scope}:${body.manifest.slug}`;
-        const current = assets.get(key) || null;
-        if (body.manifest.slug === "maintenance-agent") {
-          sendJson(response, 503, {
-            code: "cloud_mutations_maintenance",
-            retryable: true,
-            error: "Cloud mutations are temporarily disabled.",
-          }, { "retry-after": "60" });
-          return;
-        }
-        if (body.manifest.slug === "upgrade-required-agent") {
-          sendJson(response, 428, {
-            code: "client_upgrade_required",
-            current: current || descriptorFor(body, ++sequence, `cloud-test-${++cloudSequence}`),
-          });
-          return;
-        }
-        const requested = { slug: body.manifest.slug, scope, cloudId: request.headers["x-agentlas-cloud-id"] };
-        const conflict = (reason) => sendJson(response, 412, {
-          code: "cloud_agent_revision_conflict",
-          conflict: { reason, requested },
-          current,
-        }, current ? { etag: current.etag } : {});
-        if (request.headers["if-none-match"] === "*") {
-          if (current) return conflict("already_exists");
-          const created = descriptorFor(body, ++sequence, `cloud-test-${++cloudSequence}`);
-          assets.set(key, created);
-          sendJson(response, 200, {
-            schema: "agentlas.agent_cloud.registration.v1",
-            operation: "created",
-            source: scope === "hub-public" ? "hub" : "agent-cloud",
-            visibility: scope === "hub-public" ? "marketplace" : "owner-private",
-            scope,
-            owner: true,
-            publicHubPublished: scope === "hub-public",
-            ...created,
-            url: `http://agentlas.test/${created.slug}`,
-            marketplaceUrl: scope === "hub-public" ? `http://agentlas.test/p/${created.slug}` : undefined,
-            registeredAt: created.updatedAt,
-            savedAt: created.updatedAt,
-            dryRun: false,
-            billing: { modelCallsPaidBy: "none", platformModelCalls: 0 },
-          }, { etag: body.manifest.slug === "bad-etag-agent" ? '"wrong-revision"' : created.etag });
-          return;
-        }
-        if (!current) return conflict("missing_target");
-        if (
-          request.headers["if-match"] !== current.etag ||
-          request.headers["x-agentlas-cloud-id"] !== current.cloudId
-        ) return conflict("revision_mismatch");
-        const unchanged = current.packageHash === body.manifest.packageHash && current.packageHashVersion === body.manifest.packageHashVersion;
-        const next = unchanged ? current : descriptorFor(body, ++sequence, current.cloudId);
-        assets.set(key, next);
-        sendJson(response, 200, {
-          schema: "agentlas.agent_cloud.registration.v1",
-          operation: unchanged ? "unchanged" : "updated",
-          source: scope === "hub-public" ? "hub" : "agent-cloud",
-          visibility: scope === "hub-public" ? "marketplace" : "owner-private",
-          scope,
-          owner: true,
-          publicHubPublished: scope === "hub-public",
-          ...next,
-          url: `http://agentlas.test/${next.slug}`,
-          marketplaceUrl: scope === "hub-public" ? `http://agentlas.test/p/${next.slug}` : undefined,
-          registeredAt: next.updatedAt,
-          savedAt: next.updatedAt,
-          dryRun: false,
-          billing: { modelCallsPaidBy: "none", platformModelCalls: 0 },
-        }, { etag: next.etag });
-        return;
-      }
-
-      if (request.method === "DELETE") {
-        const slug = url.searchParams.get("slug");
-        const scope = url.searchParams.get("scope");
-        const cloudId = url.searchParams.get("cloudId");
-        const key = `${scope}:${slug}`;
-        const current = assets.get(key) || null;
-        if (
-          !current || current.cloudId !== cloudId ||
-          request.headers["if-match"] !== current.etag ||
-          request.headers["x-agentlas-cloud-id"] !== current.cloudId
-        ) {
-          sendJson(response, 412, {
-            code: "cloud_agent_revision_conflict",
-            conflict: { reason: "revision_mismatch", requested: { slug, scope, cloudId } },
-            current,
-          }, current ? { etag: current.etag } : {});
-          return;
-        }
-        assets.delete(key);
-        sendJson(response, 200, {
-          schema: "agentlas.agent_cloud.delete.v1",
-          ok: true,
-          source: scope === "hub-public" ? "hub" : "agent-cloud",
-          visibility: scope === "hub-public" ? "marketplace" : "owner-private",
-          ...current,
-          ...(scope === "hub-public"
-            ? { operation: "unpublished", unpublishedAt: new Date().toISOString() }
-            : { deletedAt: new Date().toISOString() }),
-        }, { etag: current.etag });
-        return;
-      }
-      sendJson(response, 405, { error: "method_not_allowed" });
-    });
-  });
-
-  try {
-    const address = await listen(server);
-    process.env.AGENTLAS_WEB_BASE_URL = `http://127.0.0.1:${address.port}`;
-
-    const updateRoot = path.join(tempDir, "update-agent");
-    writePrivateAgent(updateRoot, "Update Agent");
-    const created = await packageCloudAgentCli(null, updateRoot, { slug: "update-agent", dryRun: false, llmReview: false });
-    assert.equal(created.registration.operation, "created");
-    const createRequest = requests.at(-1);
-    assert.equal(createRequest.headers["if-none-match"], "*");
-    assert.equal(createRequest.headers["if-match"], undefined);
-    const createdMarker = JSON.parse(fs.readFileSync(path.join(updateRoot, ".agentlas-cloud-package.json"), "utf8"));
-    assert.equal(createdMarker.cloudAssets["owner-private"].revision, created.registration.revision);
-
-    fs.appendFileSync(path.join(updateRoot, "AGENTS.md"), "UPDATED_LOCALLY\n");
-    const updated = await packageCloudAgentCli(null, updateRoot, { slug: "update-agent", dryRun: false, llmReview: false });
-    assert.equal(updated.registration.operation, "updated");
-    const updateRequest = requests.at(-1);
-    assert.equal(updateRequest.headers["if-match"], created.registration.etag);
-    assert.equal(updateRequest.headers["x-agentlas-cloud-id"], created.registration.cloudId);
-    assert.equal(updateRequest.headers["if-none-match"], undefined);
-
-    const updateKey = "owner-private:update-agent";
-    const remote = { ...assets.get(updateKey) };
-    remote.revision = `rev-remote-${Date.now()}`;
-    remote.etag = `"${remote.revision}"`;
-    remote.packageHash = "f".repeat(64);
-    remote.updatedAt = new Date(Date.now() + 1000).toISOString();
-    assets.set(updateKey, remote);
-    fs.appendFileSync(path.join(updateRoot, "AGENTS.md"), "STALE_LOCAL_CHANGE\n");
-    await assert.rejects(
-      packageCloudAgentCli(null, updateRoot, { slug: "update-agent", dryRun: false, llmReview: false }),
-      (error) => error.code === "cloud_agent_revision_conflict" && /다른 PC/.test(error.message),
-    );
-    const staleMarker = JSON.parse(fs.readFileSync(path.join(updateRoot, ".agentlas-cloud-package.json"), "utf8"));
-    assert.equal(staleMarker.cloudAssets["owner-private"].revision, updated.registration.revision, "412 must never adopt the server revision automatically");
-    assert.equal(readCloudAssetStateCli().assets[updateKey].descriptor.revision, updated.registration.revision);
-
-    const foreignRoot = path.join(tempDir, "foreign-agent");
-    writePrivateAgent(foreignRoot, "Foreign Agent");
-    const foreignBody = {
-      visibility: "private-link",
-      manifest: {
-        slug: "foreign-agent",
-        packageHash: "e".repeat(64),
-        packageHashVersion: "path-sha256-executable-v2",
-      },
-    };
-    assets.set("owner-private:foreign-agent", descriptorFor(foreignBody, ++sequence, `cloud-test-${++cloudSequence}`));
-    await assert.rejects(
-      packageCloudAgentCli(null, foreignRoot, { slug: "foreign-agent", dryRun: false, llmReview: false }),
-      (error) => error.code === "cloud_agent_revision_conflict",
-    );
-    assert.equal(fs.existsSync(path.join(foreignRoot, ".agentlas-cloud-package.json")), false);
-    assert.equal(requests.at(-1).headers["if-none-match"], "*");
-
-    const upgradeRoot = path.join(tempDir, "upgrade-required-agent");
-    writePrivateAgent(upgradeRoot, "Upgrade Required Agent");
-    await assert.rejects(
-      packageCloudAgentCli(null, upgradeRoot, { slug: "upgrade-required-agent", dryRun: false, llmReview: false }),
-      (error) => error.code === "client_upgrade_required" && /자동 복사하지 않습니다/.test(error.message),
-    );
-    assert.equal(fs.existsSync(path.join(upgradeRoot, ".agentlas-cloud-package.json")), false);
-
-    const maintenanceRoot = path.join(tempDir, "maintenance-agent");
-    writePrivateAgent(maintenanceRoot, "Maintenance Agent");
-    await assert.rejects(
-      packageCloudAgentCli(null, maintenanceRoot, { slug: "maintenance-agent", dryRun: false, llmReview: false }),
-      (error) => error.code === "cloud_mutations_maintenance" && /60초.*읽기·목록·복원/.test(error.message),
-    );
-    assert.equal(fs.existsSync(path.join(maintenanceRoot, ".agentlas-cloud-package.json")), false);
-
-    const badEtagRoot = path.join(tempDir, "bad-etag-agent");
-    writePrivateAgent(badEtagRoot, "Bad ETag Agent");
-    await assert.rejects(
-      packageCloudAgentCli(null, badEtagRoot, { slug: "bad-etag-agent", dryRun: false, llmReview: false }),
-      /invalid or mismatched registration receipt/,
-    );
-    assert.equal(fs.existsSync(path.join(badEtagRoot, ".agentlas-cloud-package.json")), false);
-
-    const deleteRoot = path.join(tempDir, "delete-agent");
-    writePrivateAgent(deleteRoot, "Delete Agent");
-    const beforeDelete = await packageCloudAgentCli(null, deleteRoot, { slug: "delete-agent", dryRun: false, llmReview: false });
-    const deleted = await deleteCloudAgentCli("delete-agent", { scope: "owner-private" });
-    assert.equal(deleted.revision, beforeDelete.registration.revision);
-    const deleteRequest = requests.at(-1);
-    assert.equal(deleteRequest.method, "DELETE");
-    assert.equal(deleteRequest.url.searchParams.get("scope"), "owner-private");
-    assert.equal(deleteRequest.url.searchParams.get("cloudId"), beforeDelete.registration.cloudId);
-    assert.equal(deleteRequest.headers["if-match"], beforeDelete.registration.etag);
-    const markerAfterDelete = JSON.parse(fs.readFileSync(path.join(deleteRoot, ".agentlas-cloud-package.json"), "utf8"));
-    assert.equal(markerAfterDelete.cloudAssets["owner-private"], undefined);
-    const recreated = await packageCloudAgentCli(null, deleteRoot, { slug: "delete-agent", dryRun: false, llmReview: false });
-    assert.equal(recreated.registration.operation, "created");
-    assert.notEqual(recreated.registration.cloudId, beforeDelete.registration.cloudId);
-    assert.equal(requests.at(-1).headers["if-none-match"], "*", "delete→recreate must not reuse a deleted revision");
-
-    const staleDeleteRoot = path.join(tempDir, "stale-delete-agent");
-    writePrivateAgent(staleDeleteRoot, "Stale Delete Agent");
-    const staleDeleteBase = await packageCloudAgentCli(null, staleDeleteRoot, { slug: "stale-delete-agent", dryRun: false, llmReview: false });
-    const staleDeleteKey = "owner-private:stale-delete-agent";
-    const remotelyUpdatedDelete = { ...assets.get(staleDeleteKey) };
-    remotelyUpdatedDelete.revision = `rev-remote-delete-${Date.now()}`;
-    remotelyUpdatedDelete.etag = `"${remotelyUpdatedDelete.revision}"`;
-    remotelyUpdatedDelete.updatedAt = new Date(Date.now() + 1000).toISOString();
-    assets.set(staleDeleteKey, remotelyUpdatedDelete);
-    await assert.rejects(
-      deleteCloudAgentCli("stale-delete-agent", { scope: "owner-private" }),
-      (error) => error.code === "cloud_agent_revision_conflict" && /다른 PC/.test(error.message),
-    );
-    const staleDeleteMarker = JSON.parse(fs.readFileSync(path.join(staleDeleteRoot, ".agentlas-cloud-package.json"), "utf8"));
-    assert.equal(staleDeleteMarker.cloudAssets["owner-private"].revision, staleDeleteBase.registration.revision);
-    assert.equal(readCloudAssetStateCli().assets[staleDeleteKey].descriptor.revision, staleDeleteBase.registration.revision);
-
-    const dualRoot = path.join(tempDir, "dual-scope-agent");
-    writePublicAgent(dualRoot, "Dual Scope Agent");
-    const dualPrivate = await packageCloudAgentCli(null, dualRoot, { slug: "dual-scope-agent", dryRun: false, llmReview: false });
-    const dualPublic = await packageCloudAgentCli(null, dualRoot, { slug: "dual-scope-agent", visibility: "marketplace", dryRun: false, llmReview: false });
-    const dualMarker = JSON.parse(fs.readFileSync(path.join(dualRoot, ".agentlas-cloud-package.json"), "utf8"));
-    assert.equal(dualMarker.cloudAssets["owner-private"].revision, dualPrivate.registration.revision);
-    assert.equal(dualMarker.cloudAssets["hub-public"].revision, dualPublic.registration.revision);
-    await assert.rejects(
-      deleteCloudAgentCli("dual-scope-agent"),
-      /multiple scopes/,
-      "same slug in private/public scopes must require an exact scope",
-    );
-    await deleteCloudAgentCli("dual-scope-agent", { scope: "owner-private" });
-    const dualAfterDelete = JSON.parse(fs.readFileSync(path.join(dualRoot, ".agentlas-cloud-package.json"), "utf8"));
-    assert.equal(dualAfterDelete.cloudAssets["owner-private"], undefined);
-    assert.equal(dualAfterDelete.cloudAssets["hub-public"].revision, dualPublic.registration.revision);
-    const unpublished = await deleteCloudAgentCli("dual-scope-agent", { scope: "hub-public" });
-    assert.equal(unpublished.operation, "unpublished");
-    assert.ok(Number.isFinite(Date.parse(unpublished.unpublishedAt)));
-
-    console.log("cloud multi-host CAS client: PASS");
-  } finally {
-    await close(server).catch(() => {});
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  }
-})().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

package/test/cloud-owner-restore.cjs

@@ -1,183 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const assert = require("node:assert/strict");
-const crypto = require("node:crypto");
-const fs = require("node:fs");
-const http = require("node:http");
-const os = require("node:os");
-const path = require("node:path");
-const { execFile } = require("node:child_process");
-const { promisify } = require("node:util");
-
-const execFileAsync = promisify(execFile);
-
-function cloudFile(filePath, content) {
-  const bytes = Buffer.from(content, "utf8");
-  return {
-    path: filePath,
-    bytes: bytes.length,
-    sha256: crypto.createHash("sha256").update(bytes).digest("hex"),
-    contentBase64: bytes.toString("base64"),
-  };
-}
-
-function packageHash(files) {
-  const hash = crypto.createHash("sha256");
-  for (const file of [...files].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))) {
-    hash.update(file.path);
-    hash.update("\0");
-    hash.update(file.sha256);
-    hash.update("\0");
-  }
-  return hash.digest("hex");
-}
-
-function listen(server) {
-  return new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => resolve(server.address()));
-  });
-}
-
-function close(server) {
-  return new Promise((resolve) => server.close(resolve));
-}
-
-async function main() {
-  const userData = fs.mkdtempSync(path.join(os.tmpdir(), "agentlas-owner-cloud-"));
-  const files = [cloudFile("AGENTS.md", "# Owned Agent\n"), cloudFile("skills/core/SKILL.md", "# Core\n")];
-  const aggregate = packageHash(files);
-  const updatedAt = "2026-07-11T00:00:00.000Z";
-  const descriptorFor = (slug) => ({
-    cloudId: `cloud-${slug}`,
-    slug,
-    scope: "owner-private",
-    packageHash: aggregate,
-    packageHashVersion: "path-sha256-v1",
-    revision: `rev-${slug}-001`,
-    etag: `"rev-${slug}-001"`,
-    updatedAt,
-  });
-  const calls = [];
-  const server = http.createServer((request, response) => {
-    let raw = "";
-    request.setEncoding("utf8");
-    request.on("data", (chunk) => { raw += chunk; });
-    request.on("end", () => {
-      const body = JSON.parse(raw || "{}");
-      const name = body?.params?.name;
-      const requestedSlug = body?.params?.arguments?.slug;
-      calls.push({ name, cookie: request.headers.cookie || "" });
-      let result;
-      if (name === "cargo.search_agents") {
-        result = {
-          schema: "agentlas.agent_cloud.search.v1",
-          source: "cloud",
-          status: "ok",
-          count: 1,
-          total: 1,
-          results: [{ ...descriptorFor("owned-agent"), name: "Owned Agent", entityKind: "agent" }],
-        };
-      } else if (name === "cargo.restore_package") {
-        const responseSlug = requestedSlug === "cross-slug" ? "different-agent" : (requestedSlug || "owned-agent");
-        const descriptor = descriptorFor(responseSlug);
-        result = {
-          schema: "agentlas.agent_cloud.restore.v1",
-          source: "cloud",
-          owner: true,
-          ...descriptor,
-          name: "Owned Agent",
-          cloudPackage: {
-            ...descriptor,
-            etag: undefined,
-            agentKind: "agent",
-            fileCount: files.length,
-            totalBytes: files.reduce((sum, file) => sum + file.bytes, 0),
-            files,
-          },
-        };
-        if (requestedSlug === "mismatched-envelope") result.packageHash = "0".repeat(64);
-      } else if (name === "marketplace.get_manifest") {
-        result = {
-          slug: "call-only-agent",
-          name: "Call Only Agent",
-          delivery: {
-            mode: "call_only",
-            sourceDownload: false,
-            runtimeTool: "agentlas.get_runtime_bundle",
-            runtimeVersion: aggregate,
-          },
-        };
-      } else {
-        response.writeHead(400, { "content-type": "application/json" });
-        response.end(JSON.stringify({ error: { message: `unexpected tool: ${name}` } }));
-        return;
-      }
-      response.writeHead(200, { "content-type": "application/json" });
-      response.end(JSON.stringify({ result }));
-    });
-  });
-
-  try {
-    const address = await listen(server);
-    const env = {
-      ...process.env,
-      AGENTLAS_USER_DATA_DIR: userData,
-      AGENTLAS_MCP_BASE_URL: `http://127.0.0.1:${address.port}/api/mcp/v1`,
-      AGENTLAS_SESSION: "owner-session-fixture",
-    };
-    const bin = path.join(__dirname, "..", "bin", "agentlas.cjs");
-
-    const listed = await execFileAsync(process.execPath, [bin, "cloud", "list"], { env });
-    assert.match(listed.stdout, /owned-agent/);
-    const observedState = JSON.parse(fs.readFileSync(path.join(userData, "cloud-asset-state.v1.json"), "utf8"));
-    assert.equal(observedState.assets["owner-private:owned-agent"].descriptor.revision, "rev-owned-agent-001");
-
-    const restored = await execFileAsync(process.execPath, [bin, "cloud", "restore", "owned-agent", "--json"], { env });
-    const receipt = JSON.parse(restored.stdout);
-    assert.equal(receipt.source, "cloud");
-    assert.equal(receipt.packageHash, aggregate);
-    assert.equal(receipt.packageHashVersion, "path-sha256-v1");
-    assert.equal(receipt.revision, "rev-owned-agent-001");
-    assert.equal(receipt.etag, '"rev-owned-agent-001"');
-    const installRoot = path.join(userData, "cloud-agent-installs", "owned-agent");
-    assert.equal(fs.readFileSync(path.join(installRoot, "AGENTS.md"), "utf8"), "# Owned Agent\n");
-    const marker = JSON.parse(fs.readFileSync(path.join(installRoot, ".agentlas-cloud-package.json"), "utf8"));
-    assert.equal(marker.packageHash, aggregate);
-    assert.equal(marker.revision, "rev-owned-agent-001");
-    assert.equal(marker.cloudAssets["owner-private"].cloudId, "cloud-owned-agent");
-    await assert.rejects(
-      execFileAsync(process.execPath, [bin, "cloud", "restore", "cross-slug", "--json"], { env }),
-      (error) => /restore_slug_mismatch/.test(String(error.stderr || error)),
-    );
-    await assert.rejects(
-      execFileAsync(process.execPath, [bin, "cloud", "restore", "mismatched-envelope", "--json"], { env }),
-      (error) => /invalid_restore_contract/.test(String(error.stderr || error)),
-    );
-    assert.equal(fs.existsSync(path.join(userData, "cloud-agent-installs", "cross-slug")), false);
-    assert.equal(fs.existsSync(path.join(userData, "cloud-agent-installs", "mismatched-envelope")), false);
-    await assert.rejects(
-      execFileAsync(process.execPath, [bin, "install", "call-only-agent"], { env }),
-      (error) => /call-only.*agentlas call call-only-agent/s.test(String(error.stderr || error)),
-      "direct install must route invoke-only assets to the runtime call path",
-    );
-    assert.deepEqual(calls.map((call) => call.name), [
-      "cargo.search_agents",
-      "cargo.restore_package",
-      "cargo.restore_package",
-      "cargo.restore_package",
-      "marketplace.get_manifest",
-    ]);
-    assert.ok(calls.every((call) => call.cookie === "agentlas_session=owner-session-fixture"));
-    console.log("cloud owner list/restore: PASS");
-  } finally {
-    await close(server);
-    fs.rmSync(userData, { recursive: true, force: true });
-  }
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

package/test/cloud-runtime-paths.cjs

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const assert = require("node:assert/strict");
-const fs = require("node:fs");
-const os = require("node:os");
-const path = require("node:path");
-const { buildManifest, matches, normalizeRequestedPath, readAgentFile } = require("../engine/agentlas-cloud-runtime.cjs");
-
-const root = fs.mkdtempSync(path.join(os.tmpdir(), "agentlas-cloud-paths-"));
-try {
-  fs.mkdirSync(path.join(root, "skills", "nested", "docs"), { recursive: true });
-  fs.mkdirSync(path.join(root, "skills", "nested", "secrets"), { recursive: true });
-  fs.mkdirSync(path.join(root, "secrets"), { recursive: true });
-  fs.writeFileSync(path.join(root, "skills", "nested", "docs", "guide.md"), "safe guide\n");
-  fs.writeFileSync(path.join(root, "skills", "nested", "secrets", "key.md"), "password=fixture_secret_12345678901234567890\n");
-  fs.writeFileSync(path.join(root, "secrets", "root.md"), "blocked\n");
-  fs.writeFileSync(
-    path.join(root, "agentlas.json"),
-    JSON.stringify({
-      entry: "skills/nested/docs/guide.md",
-      allowRead: ["skills/**"],
-      denyRead: ["**/secrets/**"],
-    }),
-  );
-
-  assert.equal(matches("skills/nested/docs/guide.md", "skills/**"), true);
-  assert.equal(matches("secrets/root.md", "**/secrets/**"), true);
-  assert.equal(matches("skills/nested/secrets/key.md", "**/secrets/**"), true);
-  assert.equal(readAgentFile(root, "skills/nested/docs/guide.md").status, "allowed");
-  assert.equal(readAgentFile(root, "secrets/root.md").status, "denied");
-  assert.equal(readAgentFile(root, "skills/nested/secrets/key.md").status, "denied");
-  assert.equal(readAgentFile(root, "../outside.md").status, "denied");
-  assert.equal(readAgentFile(root, "skills/../../outside.md").status, "denied");
-  assert.equal(normalizeRequestedPath("skills\\nested\\docs\\guide.md"), "skills/nested/docs/guide.md");
-  assert.equal(buildManifest(root).createdBy, "agentlas-terminal-setup-wizard");
-  console.log("cloud runtime glob/path containment: PASS");
-} finally {
-  fs.rmSync(root, { recursive: true, force: true });
-}