@specific.dev/cli 0.1.142 → 0.1.146

package/dist/cli.js

@@ -185198,6 +185198,16 @@ import * as http from "http";
 import * as fs7 from "fs";
 import * as path7 from "path";
 import { fileURLToPath } from "url";
+import {
+  CopyObjectCommand,
+  DeleteObjectCommand,
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  ListObjectsV2Command,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
 import * as net3 from "net";
 import * as fs8 from "fs";
 import * as path9 from "path";
@@ -369113,9 +369123,9 @@ var postgresBinary = {
 };
 var redisBinary = {
   name: "redis",
-  versions: ["8.4.0"],
+  versions: ["8.1.7"],
   // URL: binaries.specific.dev/{SOFTWARE}/{VERSION}/{ARCH}.tar.gz
-  urlTemplate: "https://binaries.specific.dev/redis/{version}/{arch}.tar.gz",
+  urlTemplate: "https://binaries.specific.dev/valkey/{version}/{arch}.tar.gz",
   platformMapping: {
     darwin: {
       arm64: { platform: "macos", arch: "macos_arm" },
@@ -369128,8 +369138,7 @@ var redisBinary = {
   },
   // Binaries are at the root of the archive
   stripComponents: 0,
-  // Core Redis executable
-  executables: ["redis-server"]
+  executables: ["valkey-server"]
 };
 var electricBinary = {
   name: "electric",
@@ -369449,16 +369458,35 @@ async function startPostgres(pg, port, dataDir, onProgress) {
     }
   };
 }
-async function startRedis(redis, port, onProgress) {
+async function startRedis(redis, port, dataDir, onProgress) {
   const binary = await ensureBinary(redisBinary, void 0, onProgress);
   const host = "127.0.0.1";
+  const redisDataPath = path5.join(process.cwd(), dataDir, "redis", redis.name);
+  fs5.mkdirSync(redisDataPath, { recursive: true });
+  const stalePath = path5.join(redisDataPath, "dump.rdb");
+  if (fs5.existsSync(stalePath)) {
+    fs5.rmSync(stalePath, { force: true });
+  }
   if (await isPortInUse(host, port)) {
     await reclaimSpecificOrphanOnPort(port);
     await waitForPortFree(host, port, 1e3);
   }
   const redisProc = spawn(
-    binary.executables["redis-server"],
-    ["--port", String(port), "--bind", host, "--daemonize", "no"],
+    binary.executables["valkey-server"],
+    [
+      "--port",
+      String(port),
+      "--bind",
+      host,
+      "--daemonize",
+      "no",
+      "--dir",
+      redisDataPath,
+      "--save",
+      "",
+      "--appendonly",
+      "no"
+    ],
     {
       stdio: ["ignore", "pipe", "pipe"],
       detached: true
@@ -370448,6 +370476,417 @@ function killTrackedProcess(pid, detached, isProcessRunning) {
   } catch {
   }
 }
+var MAX_KEY_LENGTH = 1024;
+var PROXY_URL_EXPIRES_IN = 3600;
+function validateKey(key) {
+  if (!key || key.length > MAX_KEY_LENGTH) return "Invalid key length";
+  if (key.includes("..")) return "Key must not contain '..'";
+  if (key.includes("\0")) return "Key must not contain null bytes";
+  if (key.startsWith("/")) return "Key must not start with '/'";
+  return null;
+}
+var clientCache = /* @__PURE__ */ new Map();
+function getClient(info) {
+  const cacheKey = `${info.host}:${info.port}:${info.accessKey}`;
+  const cached2 = clientCache.get(cacheKey);
+  if (cached2) return cached2;
+  const client2 = new S3Client({
+    endpoint: `http://${info.host}:${info.port}`,
+    region: "us-east-1",
+    credentials: {
+      accessKeyId: info.accessKey,
+      secretAccessKey: info.secretKey
+    },
+    forcePathStyle: true
+  });
+  clientCache.set(cacheKey, client2);
+  return client2;
+}
+function sendJson(res, status, body) {
+  res.setHeader("Content-Type", "application/json");
+  res.writeHead(status);
+  res.end(JSON.stringify(body));
+}
+function sendError(res, status, message) {
+  sendJson(res, status, { error: message });
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  return text.length > 0 ? JSON.parse(text) : {};
+}
+async function handleListObjects(client2, bucket, url, res) {
+  const prefix = url.searchParams.get("prefix") ?? "";
+  const cursor = url.searchParams.get("cursor") ?? void 0;
+  const maxKeys = Math.min(
+    Math.max(parseInt(url.searchParams.get("maxKeys") ?? "100", 10) || 100, 1),
+    1e3
+  );
+  const response = await client2.send(
+    new ListObjectsV2Command({
+      Bucket: bucket,
+      Prefix: prefix,
+      Delimiter: "/",
+      MaxKeys: maxKeys,
+      ContinuationToken: cursor || void 0
+    })
+  );
+  sendJson(res, 200, {
+    objects: (response.Contents ?? []).map((obj) => ({
+      key: obj.Key,
+      size: obj.Size ?? 0,
+      lastModified: obj.LastModified?.toISOString() ?? "",
+      etag: obj.ETag
+    })),
+    prefixes: (response.CommonPrefixes ?? []).map((p) => p.Prefix),
+    nextCursor: response.NextContinuationToken ?? null,
+    prefix
+  });
+}
+async function handleMetrics(client2, bucket, res) {
+  let totalObjects = 0;
+  let totalSize = 0;
+  let continuationToken;
+  let pages = 0;
+  const MAX_PAGES = 100;
+  do {
+    const response = await client2.send(
+      new ListObjectsV2Command({
+        Bucket: bucket,
+        ContinuationToken: continuationToken
+      })
+    );
+    totalObjects += response.KeyCount ?? 0;
+    for (const obj of response.Contents ?? []) {
+      totalSize += obj.Size ?? 0;
+    }
+    continuationToken = response.NextContinuationToken;
+    pages++;
+  } while (continuationToken && pages < MAX_PAGES);
+  sendJson(res, 200, {
+    totalObjects,
+    totalSize,
+    bucketName: bucket,
+    ...pages >= MAX_PAGES ? { truncated: true } : {}
+  });
+}
+async function handleGetObject(client2, bucket, key, res) {
+  try {
+    const response = await client2.send(
+      new HeadObjectCommand({ Bucket: bucket, Key: key })
+    );
+    sendJson(res, 200, {
+      key,
+      size: response.ContentLength ?? 0,
+      lastModified: response.LastModified?.toISOString(),
+      contentType: response.ContentType,
+      etag: response.ETag,
+      metadata: response.Metadata
+    });
+  } catch (error) {
+    const name = error.name;
+    if (name === "NotFound" || name === "NoSuchKey") {
+      sendError(res, 404, `Object '${key}' not found`);
+      return;
+    }
+    throw error;
+  }
+}
+async function handleDeleteObject(client2, bucket, key, res) {
+  if (key.endsWith("/")) {
+    const allKeys = [];
+    let continuationToken;
+    do {
+      const listResponse = await client2.send(
+        new ListObjectsV2Command({
+          Bucket: bucket,
+          Prefix: key,
+          ContinuationToken: continuationToken
+        })
+      );
+      for (const obj of listResponse.Contents ?? []) {
+        if (obj.Key) allKeys.push(obj.Key);
+      }
+      continuationToken = listResponse.NextContinuationToken;
+    } while (continuationToken);
+    const batches = [];
+    for (let i = 0; i < allKeys.length; i += 1e3) {
+      batches.push(
+        client2.send(
+          new DeleteObjectsCommand({
+            Bucket: bucket,
+            Delete: {
+              Objects: allKeys.slice(i, i + 1e3).map((k) => ({ Key: k })),
+              Quiet: true
+            }
+          })
+        )
+      );
+    }
+    await Promise.all(batches);
+  } else {
+    await client2.send(new DeleteObjectCommand({ Bucket: bucket, Key: key }));
+  }
+  sendJson(res, 200, { success: true });
+}
+async function handleCreateFolder(client2, bucket, body, res) {
+  const path172 = body.path;
+  if (typeof path172 !== "string") {
+    sendError(res, 400, "Missing path");
+    return;
+  }
+  const folderKey = path172.endsWith("/") ? path172 : `${path172}/`;
+  const keyError = validateKey(folderKey);
+  if (keyError) {
+    sendError(res, 400, keyError);
+    return;
+  }
+  await client2.send(
+    new PutObjectCommand({ Bucket: bucket, Key: folderKey, Body: "" })
+  );
+  sendJson(res, 200, { key: folderKey });
+}
+async function handleRename(client2, bucket, body, res) {
+  const { sourceKey, destinationKey } = body;
+  if (typeof sourceKey !== "string" || typeof destinationKey !== "string") {
+    sendError(res, 400, "Missing sourceKey or destinationKey");
+    return;
+  }
+  for (const k of [sourceKey, destinationKey]) {
+    const err = validateKey(k);
+    if (err) {
+      sendError(res, 400, err);
+      return;
+    }
+  }
+  if (sourceKey.endsWith("/")) {
+    const allKeys = [];
+    let continuationToken;
+    do {
+      const listResponse = await client2.send(
+        new ListObjectsV2Command({
+          Bucket: bucket,
+          Prefix: sourceKey,
+          ContinuationToken: continuationToken
+        })
+      );
+      for (const obj of listResponse.Contents ?? []) {
+        if (obj.Key) allKeys.push(obj.Key);
+      }
+      continuationToken = listResponse.NextContinuationToken;
+    } while (continuationToken);
+    if (allKeys.length === 0) {
+      sendError(res, 404, "Folder is empty or does not exist");
+      return;
+    }
+    await Promise.all(
+      allKeys.map(
+        (k) => client2.send(
+          new CopyObjectCommand({
+            Bucket: bucket,
+            CopySource: `${bucket}/${encodeURI(k)}`,
+            Key: destinationKey + k.slice(sourceKey.length)
+          })
+        )
+      )
+    );
+    const deleteBatches = [];
+    for (let i = 0; i < allKeys.length; i += 1e3) {
+      deleteBatches.push(
+        client2.send(
+          new DeleteObjectsCommand({
+            Bucket: bucket,
+            Delete: {
+              Objects: allKeys.slice(i, i + 1e3).map((k) => ({ Key: k })),
+              Quiet: true
+            }
+          })
+        )
+      );
+    }
+    await Promise.all(deleteBatches);
+  } else {
+    await client2.send(
+      new CopyObjectCommand({
+        Bucket: bucket,
+        CopySource: `${bucket}/${encodeURI(sourceKey)}`,
+        Key: destinationKey
+      })
+    );
+    await client2.send(
+      new DeleteObjectCommand({ Bucket: bucket, Key: sourceKey })
+    );
+  }
+  sendJson(res, 200, { key: destinationKey });
+}
+async function handleUploadData(client2, bucket, key, req, res) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const body = Buffer.concat(chunks);
+  const contentType = req.headers["content-type"];
+  await client2.send(
+    new PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Body: body,
+      ContentType: typeof contentType === "string" ? contentType : void 0
+    })
+  );
+  res.writeHead(200);
+  res.end();
+}
+async function handleDownloadData(client2, bucket, key, res) {
+  try {
+    const response = await client2.send(
+      new GetObjectCommand({ Bucket: bucket, Key: key })
+    );
+    if (response.ContentType) {
+      res.setHeader("Content-Type", response.ContentType);
+    }
+    if (response.ContentLength !== void 0) {
+      res.setHeader("Content-Length", String(response.ContentLength));
+    }
+    res.writeHead(200);
+    const body = response.Body;
+    if (!body) {
+      res.end();
+      return;
+    }
+    if (typeof body.pipe === "function") {
+      body.pipe(res);
+    } else {
+      const stream = body.transformToWebStream();
+      const reader = stream.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) res.write(Buffer.from(value));
+      }
+      res.end();
+    }
+  } catch (error) {
+    const name = error.name;
+    if (name === "NotFound" || name === "NoSuchKey") {
+      if (!res.headersSent) {
+        sendError(res, 404, `Object '${key}' not found`);
+      } else {
+        res.end();
+      }
+      return;
+    }
+    throw error;
+  }
+}
+function handlePresigned(storageName, body, res) {
+  const { key, action, expiresIn } = body;
+  if (typeof key !== "string" || action !== "upload" && action !== "download") {
+    sendError(res, 400, "Missing key or invalid action");
+    return;
+  }
+  const keyError = validateKey(key);
+  if (keyError) {
+    sendError(res, 400, keyError);
+    return;
+  }
+  const url = `/api/storage/${encodeURIComponent(storageName)}/data?key=${encodeURIComponent(key)}`;
+  sendJson(res, 200, {
+    url,
+    expiresIn: typeof expiresIn === "number" ? expiresIn : PROXY_URL_EXPIRES_IN
+  });
+}
+async function handleStorageRequest(req, res, pathname, url, getStorageInstance) {
+  const match = /^\/api\/storage\/([^/]+)(\/.*)?$/.exec(pathname);
+  if (!match) return false;
+  const storageName = decodeURIComponent(match[1]);
+  const sub = match[2] ?? "";
+  const info = getStorageInstance(storageName);
+  if (!info) {
+    sendError(res, 404, `Storage '${storageName}' not found`);
+    return true;
+  }
+  const client2 = getClient(info);
+  const bucket = info.bucket;
+  try {
+    if (sub === "/objects" && req.method === "GET") {
+      await handleListObjects(client2, bucket, url, res);
+      return true;
+    }
+    if (sub === "/metrics" && req.method === "GET") {
+      await handleMetrics(client2, bucket, res);
+      return true;
+    }
+    if (sub === "/object") {
+      const key = url.searchParams.get("key");
+      if (!key) {
+        sendError(res, 400, "Missing key");
+        return true;
+      }
+      const keyError = validateKey(key);
+      if (keyError) {
+        sendError(res, 400, keyError);
+        return true;
+      }
+      if (req.method === "GET") {
+        await handleGetObject(client2, bucket, key, res);
+        return true;
+      }
+      if (req.method === "DELETE") {
+        await handleDeleteObject(client2, bucket, key, res);
+        return true;
+      }
+    }
+    if (sub === "/data") {
+      const key = url.searchParams.get("key");
+      if (!key) {
+        sendError(res, 400, "Missing key");
+        return true;
+      }
+      const keyError = validateKey(key);
+      if (keyError) {
+        sendError(res, 400, keyError);
+        return true;
+      }
+      if (req.method === "PUT") {
+        await handleUploadData(client2, bucket, key, req, res);
+        return true;
+      }
+      if (req.method === "GET") {
+        await handleDownloadData(client2, bucket, key, res);
+        return true;
+      }
+    }
+    if (sub === "/folder" && req.method === "POST") {
+      const body = await readJsonBody(req);
+      await handleCreateFolder(client2, bucket, body, res);
+      return true;
+    }
+    if (sub === "/rename" && req.method === "POST") {
+      const body = await readJsonBody(req);
+      await handleRename(client2, bucket, body, res);
+      return true;
+    }
+    if (sub === "/presigned" && req.method === "POST") {
+      const body = await readJsonBody(req);
+      handlePresigned(storageName, body, res);
+      return true;
+    }
+    sendError(res, 404, "Not found");
+    return true;
+  } catch (error) {
+    writeLog("admin:storage", `Storage handler error: ${error}`);
+    if (!res.headersSent) {
+      sendError(res, 500, error instanceof Error ? error.message : "Internal error");
+    } else {
+      res.end();
+    }
+    return true;
+  }
+}
 var __dirname = path7.dirname(fileURLToPath(import.meta.url));
 var adminDir = path7.join(__dirname, "admin");
 var _embeddedAdmin = null;
@@ -370515,6 +370954,19 @@ function serveEmbeddedFile(res, pathname) {
     res.end(content);
     return;
   }
+  if (!path7.extname(relativePath)) {
+    const parts = relativePath.split("/").filter(Boolean);
+    while (parts.length > 0) {
+      parts.pop();
+      const candidate = parts.length === 0 ? "index.html" : parts.join("/") + "/index.html";
+      const fallback = _embeddedAdmin.get(candidate);
+      if (fallback) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(fallback);
+        return;
+      }
+    }
+  }
   const notFound = _embeddedAdmin.get("404.html");
   if (notFound) {
     res.writeHead(404, { "Content-Type": "text/html" });
@@ -370556,6 +371008,20 @@ function serveFilesystemFile(res, pathname) {
   if (fs7.existsSync(indexPath)) {
     return serveFile(res, indexPath);
   }
+  if (!path7.extname(relativePath)) {
+    let dir = path7.dirname(resolvedPath);
+    while (dir.startsWith(resolvedAdminDir) && dir !== resolvedAdminDir) {
+      const fallback = path7.join(dir, "index.html");
+      if (fs7.existsSync(fallback)) {
+        return serveFile(res, fallback);
+      }
+      dir = path7.dirname(dir);
+    }
+    const rootIndex = path7.join(resolvedAdminDir, "index.html");
+    if (fs7.existsSync(rootIndex)) {
+      return serveFile(res, rootIndex);
+    }
+  }
   const notFoundPath = path7.join(adminDir, "404.html");
   if (fs7.existsSync(notFoundPath)) {
     return serveFileContent(res, notFoundPath, "text/html", 404);
@@ -370609,12 +371075,15 @@ function proxyRequest(req, res, targetPort) {
   });
   req.pipe(proxyReq, { end: true });
 }
-async function startAdminServer(getState, listenPort = 0, getLogsDir = () => null) {
+async function startAdminServer(getState, listenPort = 0, getLogsDir = () => null, getStorageInstance = () => void 0) {
   return new Promise((resolve62, reject) => {
     const server = http.createServer((req, res) => {
       const url = new URL(req.url || "/", "http://localhost");
       res.setHeader("Access-Control-Allow-Origin", "*");
-      res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+      res.setHeader(
+        "Access-Control-Allow-Methods",
+        "GET, POST, PUT, DELETE, OPTIONS"
+      );
       res.setHeader("Access-Control-Allow-Headers", "Content-Type");
       if (req.method === "OPTIONS") {
         res.writeHead(204);
@@ -370688,6 +371157,10 @@ async function startAdminServer(getState, listenPort = 0, getLogsDir = () => nul
         res.end(JSON.stringify(body));
         return;
       }
+      if (pathname.startsWith("/api/storage/")) {
+        void handleStorageRequest(req, res, pathname, url, getStorageInstance);
+        return;
+      }
       if (pathname.startsWith("/temporal-ui")) {
         const state = getState();
         if (state.temporalUiPort) {
@@ -371686,7 +372159,7 @@ async function startResources(options2) {
     const port = portAllocator.allocate(`redis:${redis.name}`);
     log(`Starting redis "${redis.name}" on port ${port}`);
     callbacks.onResourceStarting?.(redis.name, "redis");
-    const instance = await startRedis(redis, port, (progress) => {
+    const instance = await startRedis(redis, port, dataDir, (progress) => {
       callbacks.onResourceProgress?.(redis.name, progress);
     });
     resources.set(redis.name, instance);
@@ -373315,7 +373788,20 @@ Add them to the config block in specific.local`
     const adminServer = await startAdminServer(
       getState,
       adminPort,
-      () => this.serviceLogFiles?.logsDir ?? null
+      () => this.serviceLogFiles?.logsDir ?? null,
+      (name) => {
+        const r = this.resources.get(name);
+        if (!r || r.type !== "storage" || !r.bucket || !r.accessKey || !r.secretKey) {
+          return void 0;
+        }
+        return {
+          host: r.host,
+          port: r.port,
+          bucket: r.bucket,
+          accessKey: r.accessKey,
+          secretKey: r.secretKey
+        };
+      }
     );
     this.adminServer = adminServer;
     this.systemLog(
@@ -373905,7 +374391,7 @@ function getProjectId() {
   }
   return void 0;
 }
-function getClient() {
+function getClient2() {
   if (!isEnabled()) return null;
   if (!client) {
     client = new PostHog("phc_qNQCEUXh6ErdciQRRmeG2xlVvwFjkcW6A5bnOFJ8vXZ", {
@@ -373918,7 +374404,7 @@ function getClient() {
   return client;
 }
 function trackEvent(event, properties) {
-  const ph = getClient();
+  const ph = getClient2();
   if (!ph) return;
   const userId = getUserId();
   if (userId && !identified) {
@@ -373939,7 +374425,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.142",
+      cli_version: "0.1.146",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId()
@@ -376182,6 +376668,7 @@ function DeployUI({ envFlag, preview, config }) {
           setState((s) => ({
             ...s,
             phase: "creating-tarball",
+            environmentId: match.id,
             environmentName: match.name,
             environments
           }));
@@ -376195,6 +376682,7 @@ function DeployUI({ envFlag, preview, config }) {
             setState((s) => ({
               ...s,
               phase: "creating-tarball",
+              environmentId: match.id,
               environmentName: match.name,
               environments
             }));
@@ -376206,6 +376694,7 @@ function DeployUI({ envFlag, preview, config }) {
           setState((s) => ({
             ...s,
             phase: "creating-tarball",
+            environmentId: environments[0].id,
             environmentName: environments[0].name,
             environments
           }));
@@ -376254,6 +376743,7 @@ function DeployUI({ envFlag, preview, config }) {
         setState((s) => ({
           ...s,
           phase: "creating-tarball",
+          environmentId: previewEnv.id,
           environmentName: previewEnv.name
         }));
       } catch (err) {
@@ -376275,6 +376765,7 @@ function DeployUI({ envFlag, preview, config }) {
       setState((s) => ({
         ...s,
         phase: "creating-tarball",
+        environmentId: env2.id,
         environmentName: env2.name
       }));
     },
@@ -376426,7 +376917,7 @@ function DeployUI({ envFlag, preview, config }) {
   }, [state]);
   const environment = state.environmentName || "prod";
   useEffect6(() => {
-    if (state.phase !== "creating-tarball" || !state.projectId || !state.environmentName) return;
+    if (state.phase !== "creating-tarball" || !state.projectId || !state.environmentId || !state.environmentName) return;
     let cancelled = false;
     async function runDeploy() {
       const projectDir = process.cwd();
@@ -376462,7 +376953,7 @@ function DeployUI({ envFlag, preview, config }) {
       try {
         writeLog("deploy", `Creating deployment for project ${state.projectId}`);
         const gitInfo = getGitInfo(projectDir);
-        deployment2 = await client2.createDeployment(state.projectId, state.environmentName, {
+        deployment2 = await client2.createDeployment(state.projectId, state.environmentId, {
           triggeredBy: "cli",
           ...gitInfo && {
             gitCommitSha: gitInfo.commitSha,
@@ -376927,7 +377418,7 @@ async function runDeployPipeline(options2) {
   const projects = await client2.listProjects();
   const project = projects.find((p) => p.id === projectId);
   const environments = project?.environments ?? [];
-  let environmentName;
+  let environmentId;
   if (options2.environment) {
     const match = findEnvironmentByNameOrId(environments, options2.environment);
     if (!match) {
@@ -376937,15 +377428,15 @@ async function runDeployPipeline(options2) {
       );
       process.exit(1);
     }
-    environmentName = match.name;
+    environmentId = match.id;
     writeEnvironmentId(match.id);
   } else if (hasEnvironmentId(projectDir)) {
     const savedEnvId = readEnvironmentId(projectDir);
     const env2 = environments.find((e) => e.id === savedEnvId);
     if (env2) {
-      environmentName = env2.name;
+      environmentId = env2.id;
     } else if (environments.length === 1) {
-      environmentName = environments[0].name;
+      environmentId = environments[0].id;
       writeEnvironmentId(environments[0].id);
     } else if (environments.length === 0) {
       console.error("Error: No environments found for this project");
@@ -376960,7 +377451,7 @@ async function runDeployPipeline(options2) {
     }
   } else {
     if (environments.length === 1) {
-      environmentName = environments[0].name;
+      environmentId = environments[0].id;
       writeEnvironmentId(environments[0].id);
     } else if (environments.length === 0) {
       console.error("Error: No environments found for this project");
@@ -377007,7 +377498,7 @@ async function runDeployPipeline(options2) {
   let deployment;
   try {
     const gitInfo = getGitInfo(projectDir);
-    deployment = await client2.createDeployment(projectId, environmentName, {
+    deployment = await client2.createDeployment(projectId, environmentId, {
       triggeredBy: "cli",
       ...gitInfo && {
         gitCommitSha: gitInfo.commitSha,
@@ -378050,7 +378541,7 @@ function compareVersions(a, b) {
   return 0;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.142";
+  const currentVersion = "0.1.146";
   const response = await fetch(`${BINARIES_BASE_URL}/latest?t=${Date.now()}`);
   if (!response.ok) {
     throw new Error(`Failed to check for updates: HTTP ${response.status}`);
@@ -378565,7 +379056,7 @@ function friendlyErrorMessage(raw) {
 var program = new Command();
 var env = "production";
 var envLabel = env !== "production" ? `[${env.toUpperCase()}] ` : "";
-program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.142").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.146").enablePositionalOptions();
 program.command("init").description("Initialize project for use with a coding agent").option("--agent <name...>", "Agents to configure (cursor, claude, codex, other)").addHelpText("after", `
 Examples:
   $ specific init