@foldspace_npm/harness 0.1.0

package/bin/buildExtension.mjs

@@ -0,0 +1,90 @@
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectDir = process.env.FOLDSPACE_PROJECT_DIR || process.cwd();
+const indexPath = path.join(projectDir, "extension", "index.js");
+
+const LOAD_LOCALLY_TRUE = "const LOAD_LOCALLY = true;";
+const LOAD_LOCALLY_FALSE = "const LOAD_LOCALLY = false;";
+const REMOTE_ENV_DEV = 'const REMOTE_ACTIONS_ENV = "DEV";';
+const REMOTE_ENV_PROD = 'const REMOTE_ACTIONS_ENV = "PROD";';
+
+function parseArgs(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--env" && argv[i + 1]) return argv[++i];
+  }
+  return null;
+}
+
+const env = parseArgs(process.argv.slice(2));
+if (!env || (env !== "dev" && env !== "prod")) {
+  console.error('buildExtension: --env <dev|prod> is required');
+  process.exit(1);
+}
+
+function replaceInIndex(from, to, label) {
+  const source = fs.readFileSync(indexPath, "utf8");
+
+  if (!source.includes(from)) {
+    if (source.includes(to)) {
+      console.log(`buildExtension: ${label} already set`);
+      return;
+    }
+    console.error(
+      `buildExtension: expected ${label} pattern not found in index.js`,
+    );
+    process.exit(1);
+  }
+
+  fs.writeFileSync(indexPath, source.replace(from, to), "utf8");
+  console.log(`buildExtension: ${label} → ${to}`);
+}
+
+function setLoadLocally(value) {
+  if (!fs.existsSync(indexPath)) {
+    console.error("buildExtension: extension/index.js not found");
+    process.exit(1);
+  }
+  const from = value ? LOAD_LOCALLY_FALSE : LOAD_LOCALLY_TRUE;
+  const to = value ? LOAD_LOCALLY_TRUE : LOAD_LOCALLY_FALSE;
+  replaceInIndex(from, to, "LOAD_LOCALLY");
+}
+
+function setRemoteActionsEnv(targetEnv) {
+  const from = targetEnv === "dev" ? REMOTE_ENV_PROD : REMOTE_ENV_DEV;
+  const to = targetEnv === "dev" ? REMOTE_ENV_DEV : REMOTE_ENV_PROD;
+  replaceInIndex(from, to, "REMOTE_ACTIONS_ENV");
+}
+
+let failed = false;
+
+try {
+  execFileSync("tsx", ["scripts/build.ts"], {
+    cwd: projectDir,
+    stdio: "inherit",
+  });
+
+  setLoadLocally(false);
+  setRemoteActionsEnv(env);
+
+  execFileSync("node", ["scripts/packageExtension.mjs"], {
+    cwd: projectDir,
+    stdio: "inherit",
+  });
+} catch {
+  failed = true;
+} finally {
+  try {
+    setLoadLocally(true);
+    setRemoteActionsEnv("prod");
+  } catch {
+    failed = true;
+  }
+}
+
+if (failed) {
+  process.exit(1);
+}

package/bin/cli.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+import { initUsage, runInit } from "../src/init.mjs";
+
+const usage = `Usage:
+  ${initUsage}
+
+Commands:
+  init  Create a configured Foldspace actions project
+`;
+
+function fail(message) {
+  console.error(`foldspace: ${message}`);
+  process.exitCode = 1;
+}
+
+const [command, ...args] = process.argv.slice(2);
+
+if (!command || command === "--help" || command === "-h") {
+  console.log(usage);
+} else if (command === "init") {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`Usage: ${initUsage}`);
+  } else {
+    try {
+      runInit(args);
+    } catch (error) {
+      fail(error instanceof Error ? error.message : String(error));
+    }
+  }
+} else {
+  fail(`unknown command '${command}'\n\n${usage}`);
+}

package/bin/deploy.mjs

@@ -0,0 +1,220 @@
+import { execFileSync, execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectDir = process.env.FOLDSPACE_PROJECT_DIR || process.cwd();
+
+const GCS_BUCKET = "prod-us1-eucera-public-scripts";
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--env" && argv[i + 1]) args.env = argv[++i];
+  }
+  return args;
+}
+
+function readExtensionConfig() {
+  const indexPath = path.join(projectDir, "extension", "index.js");
+  if (!fs.existsSync(indexPath)) {
+    console.error("deploy: extension/index.js not found");
+    process.exit(1);
+  }
+  const src = fs.readFileSync(indexPath, "utf8");
+
+  const productMatch = src.match(/const\s+PRODUCT_ID\s*=\s*["'](.+?)["']/);
+  const agentMatch = src.match(/const\s+AGENT_API_NAME\s*=\s*["'](.+?)["']/);
+
+  if (!productMatch || !productMatch[1]) {
+    console.error("deploy: could not read PRODUCT_ID from extension/index.js");
+    process.exit(1);
+  }
+  if (!agentMatch || !agentMatch[1]) {
+    console.error(
+      "deploy: could not read AGENT_API_NAME from extension/index.js",
+    );
+    process.exit(1);
+  }
+
+  return { productId: productMatch[1], agentApiName: agentMatch[1] };
+}
+
+function validate(args) {
+  const errors = [];
+  if (args.env !== "dev" && args.env !== "prod")
+    errors.push('--env must be "dev" or "prod"');
+  if (errors.length) {
+    console.error("deploy: validation failed:");
+    errors.forEach((e) => console.error(`  - ${e}`));
+    console.error("\nUsage: node scripts/deploy.mjs [--env <dev|prod>]");
+    process.exit(1);
+  }
+}
+
+function getGitCommitHash() {
+  try {
+    return execSync("git rev-parse --short HEAD", { cwd: projectDir })
+      .toString()
+      .trim();
+  } catch {
+    return "unknown";
+  }
+}
+
+function readDeployVersion() {
+  const sha = getGitCommitHash();
+  if (sha === "unknown") {
+    console.error("deploy: could not resolve git commit SHA");
+    process.exit(1);
+  }
+  return sha;
+}
+
+function gcsBasePath(env, productId, agentApiName) {
+  return `gs://${GCS_BUCKET}/agent/actions/${env}/${productId}/${agentApiName}`;
+}
+
+function versionExistsInGCS(basePath, version) {
+  const target = `${basePath}/index.${version}.js`;
+  try {
+    execFileSync("gsutil", ["stat", target], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function uploadToGCS(distFile, basePath, version) {
+  const versionedTarget = `${basePath}/index.${version}.js`;
+  const latestTarget = `${basePath}/index.js`;
+
+  console.log(`\nUploading versioned: ${versionedTarget}`);
+  execFileSync("gsutil", ["cp", "-z", "js", distFile, versionedTarget], {
+    stdio: "inherit",
+  });
+
+  console.log(`Uploading latest:    ${latestTarget}`);
+  execFileSync(
+    "gsutil",
+    [
+      "-h",
+      "Cache-Control:no-cache, max-age=0",
+      "-h",
+      "Content-Type:application/javascript",
+      "cp",
+      "-z",
+      "js",
+      distFile,
+      latestTarget,
+    ],
+    { stdio: "inherit" },
+  );
+}
+
+function getGitUserName() {
+  try {
+    return execSync("git config user.name", { cwd: projectDir })
+      .toString()
+      .trim();
+  } catch {
+    return "unknown";
+  }
+}
+
+function getLastDeployCommitHash(deploymentsPath) {
+  if (!fs.existsSync(deploymentsPath)) return null;
+  const content = fs.readFileSync(deploymentsPath, "utf8");
+  const match = content.match(/> Commit: ([a-f0-9]+)/);
+  return match ? match[1] : null;
+}
+
+function getGitLogSince(sinceHash) {
+  try {
+    const range = sinceHash ? `${sinceHash}..HEAD` : "HEAD~10..HEAD";
+    const log = execSync(`git log ${range} --oneline`, { cwd: projectDir })
+      .toString()
+      .trim();
+    if (!log) return ["No changes recorded"];
+    return log.split("\n").map((line) => {
+      const spaceIdx = line.indexOf(" ");
+      return spaceIdx > 0 ? line.substring(spaceIdx + 1) : line;
+    });
+  } catch {
+    return ["Unable to retrieve git log"];
+  }
+}
+
+function updateDeployments(env, version) {
+  const deploymentsPath = path.join(projectDir, "DEPLOYMENTS.md");
+  const commitHash = getGitCommitHash();
+  const deployer = getGitUserName();
+  const date = new Date().toISOString().split("T")[0];
+
+  const lastHash = getLastDeployCommitHash(deploymentsPath);
+  const changes = getGitLogSince(lastHash);
+
+  const entry = [
+    `## ${version} | ${env} | ${date}`,
+    "",
+    ...changes.map((msg) => `- ${msg}`),
+    `> Commit: ${commitHash} | Deployed by: ${deployer}`,
+    "",
+  ].join("\n");
+
+  if (fs.existsSync(deploymentsPath)) {
+    const existing = fs.readFileSync(deploymentsPath, "utf8");
+    const headerEnd = existing.indexOf("\n\n");
+    if (headerEnd !== -1) {
+      const header = existing.substring(0, headerEnd);
+      const rest = existing.substring(headerEnd + 2);
+      fs.writeFileSync(deploymentsPath, `${header}\n\n${entry}\n${rest}`);
+    } else {
+      fs.writeFileSync(deploymentsPath, `${existing}\n\n${entry}`);
+    }
+  } else {
+    fs.writeFileSync(deploymentsPath, `# Deployments\n\n${entry}`);
+  }
+
+  console.log(`\nUpdated DEPLOYMENTS.md`);
+}
+
+function deploy() {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.env) args.env = "dev";
+
+  const { productId, agentApiName } = readExtensionConfig();
+  args.productId = productId;
+  args.agentApiName = agentApiName;
+
+  validate(args);
+
+  const version = readDeployVersion();
+  const distFile = path.join(projectDir, "dist", "index.js");
+
+  if (!fs.existsSync(distFile)) {
+    console.error(`deploy: dist/index.js not found. Run build first.`);
+    process.exit(1);
+  }
+
+  const basePath = gcsBasePath(args.env, args.productId, args.agentApiName);
+
+  console.log(`deploy: ${version} -> ${args.env}`);
+  console.log(`deploy: bucket ${GCS_BUCKET}`);
+  console.log(`deploy: path   ${basePath}`);
+
+  if (versionExistsInGCS(basePath, version)) {
+    console.log(
+      `\ndeploy: ${version} already deployed at ${basePath}/index.${version}.js — skipping`,
+    );
+    return;
+  }
+
+  uploadToGCS(distFile, basePath, version);
+  updateDeployments(args.env, version);
+
+  console.log(`\ndeploy: ${version} deployed successfully to ${args.env}`);
+}
+
+deploy();