shiplocal 0.1.5 → 0.1.6

package/dist/index.js

@@ -1,10 +1,121 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/env-rewrite.ts
+var env_rewrite_exports = {};
+__export(env_rewrite_exports, {
+  runEnvRewrite: () => runEnvRewrite
+});
+import { copyFile, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+function localhostPattern(port) {
+  return new RegExp(`https?://(?:127\\.0\\.0\\.1|localhost):${String(port)}(?:/|$)`, "i");
+}
+function findReplacements(file, content, port, publicUrl, siblingUrls) {
+  const replacements = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    const value = trimmed.slice(eqIndex + 1).trim().replace(/^["']|["']$/g, "");
+    if (!ENV_KEY_PATTERN.test(key)) continue;
+    if (localhostPattern(port).test(value)) {
+      replacements.push({ file, key, from: value, to: publicUrl });
+      continue;
+    }
+    for (const sibling of siblingUrls) {
+      if (localhostPattern(sibling.port).test(value)) {
+        replacements.push({ file, key, from: value, to: sibling.publicUrl });
+        break;
+      }
+    }
+  }
+  return replacements;
+}
+function applyReplacements(content, replacements) {
+  let updated = content;
+  for (const replacement of replacements) {
+    const pattern = new RegExp(
+      `^(${replacement.key}\\s*=\\s*["']?)${replacement.from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(["']?)`,
+      "m"
+    );
+    updated = updated.replace(pattern, `$1${replacement.to}$2`);
+  }
+  return updated;
+}
+async function runEnvRewrite(options) {
+  const allReplacements = [];
+  for (const fileName of ENV_FILES) {
+    const filePath = join2(process.cwd(), fileName);
+    try {
+      const content = await readFile2(filePath, "utf8");
+      allReplacements.push(
+        ...findReplacements(
+          fileName,
+          content,
+          options.port,
+          options.publicUrl,
+          options.siblingUrls
+        )
+      );
+    } catch {
+    }
+  }
+  if (allReplacements.length === 0) {
+    if (options.write) {
+      console.log("No matching localhost env vars found to rewrite.");
+    }
+    return;
+  }
+  console.log("");
+  console.log(options.write ? "Applying .env updates:" : "Suggested .env updates:");
+  for (const replacement of allReplacements) {
+    console.log(`  ${replacement.file}: ${replacement.key}`);
+    console.log(`    ${replacement.from}`);
+    console.log(`    \u2192 ${replacement.to}`);
+  }
+  if (!options.write) {
+    console.log("");
+    console.log("Run with --rewrite-env to apply these changes.");
+    return;
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const replacement of allReplacements) {
+    const list = byFile.get(replacement.file) ?? [];
+    list.push(replacement);
+    byFile.set(replacement.file, list);
+  }
+  for (const [fileName, replacements] of byFile) {
+    const filePath = join2(process.cwd(), fileName);
+    const content = await readFile2(filePath, "utf8");
+    const backupPath = `${filePath}.shiplocal.bak`;
+    await copyFile(filePath, backupPath);
+    const updated = applyReplacements(content, replacements);
+    await writeFile2(filePath, updated, "utf8");
+    console.log(`  Updated ${fileName} (backup: ${fileName}.shiplocal.bak)`);
+  }
+  console.log("");
+}
+var ENV_FILES, ENV_KEY_PATTERN;
+var init_env_rewrite = __esm({
+  "src/env-rewrite.ts"() {
+    "use strict";
+    ENV_FILES = [".env", ".env.local", ".env.development"];
+    ENV_KEY_PATTERN = /^(NEXT_PUBLIC_|VITE_|REACT_APP_|PUBLIC_|API_|BACKEND_|FRONTEND_)/;
+  }
+});
+
 // src/index.ts
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
@@ -4061,8 +4172,20 @@ var loginSchema = external_exports.object({
   email: external_exports.string().email(),
   password: external_exports.string().min(1).max(128)
 });
+var forgotPasswordSchema = external_exports.object({
+  email: external_exports.string().email()
+});
+var resetPasswordSchema = external_exports.object({
+  token: external_exports.string().min(1),
+  password: external_exports.string().min(8).max(128)
+});
+var changePasswordSchema = external_exports.object({
+  currentPassword: external_exports.string().min(1).max(128).optional(),
+  newPassword: external_exports.string().min(8).max(128)
+});
 var createProjectSchema = external_exports.object({
-  name: external_exports.string().min(1).max(100)
+  name: external_exports.string().min(1).max(100),
+  slug: external_exports.string().min(2).max(48).optional()
 });
 
 // ../shared/dist/constants.js
@@ -4073,11 +4196,19 @@ var TUNNEL_WS_PATH = "/tunnel";
 var DEFAULT_TUNNEL_EXPIRY_MS = 2 * 60 * 60 * 1e3;
 var MAX_BODY_BYTES = 50 * 1024 * 1024;
 var headersSchema = external_exports.record(external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]));
+var siblingTunnelSchema = external_exports.object({
+  name: external_exports.string(),
+  publicUrl: external_exports.string().url(),
+  port: external_exports.number().int()
+});
 var registerMessageSchema = external_exports.object({
   type: external_exports.literal("register"),
   localPort: external_exports.number().int().min(1).max(65535),
   token: external_exports.string().optional(),
   projectId: external_exports.string().optional(),
+  projectSlug: external_exports.string().optional(),
+  targetName: external_exports.string().optional(),
+  tunnelId: external_exports.string().optional(),
   password: external_exports.string().min(4).max(128).optional()
 });
 var registeredMessageSchema = external_exports.object({
@@ -4085,7 +4216,10 @@ var registeredMessageSchema = external_exports.object({
   tunnelId: external_exports.string(),
   subdomain: external_exports.string(),
   publicUrl: external_exports.string().url(),
-  expiresAt: external_exports.string()
+  expiresAt: external_exports.string(),
+  projectSlug: external_exports.string().optional(),
+  targetName: external_exports.string().optional(),
+  siblingUrls: external_exports.array(siblingTunnelSchema).optional()
 });
 var pingMessageSchema = external_exports.object({ type: external_exports.literal("ping") });
 var pongMessageSchema = external_exports.object({ type: external_exports.literal("pong") });
@@ -4105,6 +4239,24 @@ var tunnelResponseMessageSchema = external_exports.object({
   headers: headersSchema,
   body: external_exports.string().optional()
 });
+var tunnelWebSocketOpenMessageSchema = external_exports.object({
+  type: external_exports.literal("ws-open"),
+  id: external_exports.string(),
+  path: external_exports.string(),
+  query: external_exports.string(),
+  headers: headersSchema
+});
+var tunnelWebSocketMessageSchema = external_exports.object({
+  type: external_exports.literal("ws-message"),
+  id: external_exports.string(),
+  body: external_exports.string()
+});
+var tunnelWebSocketCloseMessageSchema = external_exports.object({
+  type: external_exports.literal("ws-close"),
+  id: external_exports.string(),
+  code: external_exports.number().int().optional(),
+  reason: external_exports.string().optional()
+});
 var errorMessageSchema = external_exports.object({
   type: external_exports.literal("error"),
   message: external_exports.string()
@@ -4120,6 +4272,9 @@ var tunnelMessageSchema = external_exports.discriminatedUnion("type", [
   pongMessageSchema,
   tunnelRequestMessageSchema,
   tunnelResponseMessageSchema,
+  tunnelWebSocketOpenMessageSchema,
+  tunnelWebSocketMessageSchema,
+  tunnelWebSocketCloseMessageSchema,
   errorMessageSchema,
   terminatedMessageSchema
 ]);
@@ -4153,12 +4308,22 @@ var healthResponseSchema = external_exports.object({
   timestamp: external_exports.string()
 });
 
+// ../shared/dist/slug.js
+function normalizeTargetName(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 32);
+}
+
 // ../tunnel-client/dist/client.js
 import { WebSocket } from "ws";
 
 // ../tunnel-client/dist/local-proxy.js
 import http from "node:http";
+import { promisify } from "node:util";
+import { brotliCompress, constants as zlibConstants, gzip } from "node:zlib";
 var LOOPBACK_HOSTS = ["127.0.0.1", "::1"];
+var gzipAsync = promisify(gzip);
+var brotliCompressAsync = promisify(brotliCompress);
+var MIN_COMPRESS_BYTES = 1024;
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
   "keep-alive",
@@ -4169,11 +4334,19 @@ var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "transfer-encoding",
   "upgrade"
 ]);
-var STRIP_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
-  ...HOP_BY_HOP_HEADERS,
-  "content-encoding",
-  "content-length"
-]);
+var STRIP_RESPONSE_HEADERS = /* @__PURE__ */ new Set([...HOP_BY_HOP_HEADERS, "content-length"]);
+var COMPRESSIBLE_CONTENT_TYPES = [
+  "application/javascript",
+  "application/json",
+  "application/manifest+json",
+  "application/rss+xml",
+  "application/vnd.apple.mpegurl",
+  "application/wasm",
+  "application/x-javascript",
+  "application/xml",
+  "image/svg+xml",
+  "text/"
+];
 function isConnectionRefused(err) {
   return err instanceof Error && "code" in err && err.code === "ECONNREFUSED";
 }
@@ -4181,7 +4354,7 @@ function sanitizeRequestHeaders(headers, localPort) {
   const result = {};
   for (const [key, value] of Object.entries(headers)) {
     const lower = key.toLowerCase();
-    if (HOP_BY_HOP_HEADERS.has(lower) || lower === "host" || lower === "accept-encoding") {
+    if (HOP_BY_HOP_HEADERS.has(lower) || lower === "host") {
       continue;
     }
     result[key] = value;
@@ -4201,6 +4374,73 @@ function sanitizeResponseHeaders(headers) {
   }
   return result;
 }
+function headerValue(value) {
+  if (value === void 0)
+    return void 0;
+  return Array.isArray(value) ? value[0] : value;
+}
+function getHeader(headers, name) {
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowerName)
+      return headerValue(value);
+  }
+  return void 0;
+}
+function mergeVary(existing, value) {
+  if (!existing)
+    return value;
+  const parts = existing.split(",").map((part) => part.trim().toLowerCase());
+  if (parts.includes(value.toLowerCase()))
+    return existing;
+  return `${existing}, ${value}`;
+}
+function setHeader(headers, name, value) {
+  const next = Object.fromEntries(Object.entries(headers).filter(([key]) => key.toLowerCase() !== name.toLowerCase()));
+  next[name] = value;
+  return next;
+}
+function stripHeader(headers, name) {
+  return Object.fromEntries(Object.entries(headers).filter(([key]) => key.toLowerCase() !== name.toLowerCase()));
+}
+function isCompressibleContentType(contentType) {
+  if (!contentType)
+    return false;
+  const normalized = contentType.toLowerCase();
+  if (normalized.includes("text/html"))
+    return false;
+  return COMPRESSIBLE_CONTENT_TYPES.some((type) => normalized.includes(type));
+}
+async function maybeCompressResponse(body, responseHeaders, requestHeaders) {
+  const headers = sanitizeResponseHeaders(responseHeaders);
+  if (body.length < MIN_COMPRESS_BYTES || getHeader(responseHeaders, "content-encoding") || getHeader(responseHeaders, "content-range") || !isCompressibleContentType(getHeader(responseHeaders, "content-type"))) {
+    return { body, headers };
+  }
+  const acceptEncoding = getHeader(requestHeaders, "accept-encoding") ?? "";
+  if (/\bbr\b/.test(acceptEncoding)) {
+    const compressed = await brotliCompressAsync(body, {
+      params: {
+        [zlibConstants.BROTLI_PARAM_QUALITY]: 4
+      }
+    });
+    const vary = mergeVary(getHeader(headers, "vary"), "Accept-Encoding");
+    const compressedHeaders = setHeader(stripHeader(headers, "etag"), "content-encoding", "br");
+    return {
+      body: compressed,
+      headers: setHeader(compressedHeaders, "vary", vary)
+    };
+  }
+  if (/\bgzip\b/.test(acceptEncoding)) {
+    const compressed = await gzipAsync(body, { level: 6 });
+    const vary = mergeVary(getHeader(headers, "vary"), "Accept-Encoding");
+    const compressedHeaders = setHeader(stripHeader(headers, "etag"), "content-encoding", "gzip");
+    return {
+      body: compressed,
+      headers: setHeader(compressedHeaders, "vary", vary)
+    };
+  }
+  return { body, headers };
+}
 function forwardToHost(hostname, localPort, message, body, pathWithQuery) {
   return new Promise((resolve, reject) => {
     const req = http.request({
@@ -4222,14 +4462,17 @@ function forwardToHost(hostname, localPort, message, body, pathWithQuery) {
         chunks.push(chunk);
       });
       res.on("end", () => {
-        const responseBody = Buffer.concat(chunks);
-        resolve({
-          type: "response",
-          id: message.id,
-          status: res.statusCode ?? 502,
-          headers: sanitizeResponseHeaders(res.headers),
-          body: responseBody.length > 0 ? encodeBody(responseBody) : void 0
-        });
+        void (async () => {
+          const responseBody = Buffer.concat(chunks);
+          const { body: encodedBody, headers } = await maybeCompressResponse(responseBody, res.headers, message.headers);
+          resolve({
+            type: "response",
+            id: message.id,
+            status: res.statusCode ?? 502,
+            headers,
+            body: encodedBody.length > 0 ? encodeBody(encodedBody) : void 0
+          });
+        })().catch(reject);
       });
     });
     req.on("error", (err) => {
@@ -4256,7 +4499,10 @@ async function forwardToLocal(localPort, message) {
       throw err;
     }
   }
-  throw lastError ?? new Error("Local server unreachable");
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new Error("Local server unreachable");
 }
 
 // ../tunnel-client/dist/client.js
@@ -4290,16 +4536,65 @@ function rawDataToString(raw) {
     return Buffer.concat(raw).toString("utf8");
   return Buffer.from(raw).toString("utf8");
 }
+function rawDataToBuffer(raw) {
+  if (typeof raw === "string")
+    return Buffer.from(raw, "utf8");
+  if (Buffer.isBuffer(raw))
+    return raw;
+  if (Array.isArray(raw))
+    return Buffer.concat(raw);
+  return Buffer.from(raw);
+}
+function sanitizeWebSocketHeaders(headers, localPort) {
+  const result = {};
+  const skip = /* @__PURE__ */ new Set([
+    "connection",
+    "host",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "sec-websocket-accept",
+    "sec-websocket-extensions",
+    "sec-websocket-key",
+    "sec-websocket-version",
+    "te",
+    "trailers",
+    "transfer-encoding",
+    "upgrade"
+  ]);
+  for (const [key, value] of Object.entries(headers)) {
+    const lower = key.toLowerCase();
+    if (skip.has(lower))
+      continue;
+    result[key] = lower === "origin" ? `http://localhost:${String(localPort)}` : value;
+  }
+  result["host"] = `localhost:${String(localPort)}`;
+  return result;
+}
+function toLocalWebSocketUrl(localPort, message) {
+  const url = new URL(`ws://localhost:${String(localPort)}`);
+  url.pathname = message.path;
+  url.search = message.query ? `?${message.query}` : "";
+  return url.toString();
+}
+function validCloseCode(code) {
+  if (code === void 0)
+    return void 0;
+  return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999 ? code : void 0;
+}
 function createTunnelClient(options) {
   let ws = null;
   let reconnectTimer = null;
   let reconnectAttempt = 0;
   let intentionalClose = false;
   let publicUrl = null;
+  let registeredTunnelId = options.tunnelId ?? null;
   let connectPromise = null;
   let connectResolve = null;
   let connectReject = null;
   let hasRegistered = false;
+  const localWebSockets = /* @__PURE__ */ new Map();
+  const pendingLocalWebSocketMessages = /* @__PURE__ */ new Map();
   const clearReconnect = () => {
     if (reconnectTimer) {
       clearTimeout(reconnectTimer);
@@ -4312,6 +4607,72 @@ function createTunnelClient(options) {
       connectReject = reject;
     });
   };
+  const sendControlMessage = (message) => {
+    if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(message));
+    }
+  };
+  const closeLocalWebSockets = () => {
+    for (const socket of localWebSockets.values()) {
+      socket.removeAllListeners();
+      if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
+        socket.close();
+      }
+    }
+    localWebSockets.clear();
+  };
+  const closeLocalWebSocket = (message) => {
+    const socket = localWebSockets.get(message.id);
+    if (!socket)
+      return;
+    localWebSockets.delete(message.id);
+    pendingLocalWebSocketMessages.delete(message.id);
+    if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
+      socket.close(validCloseCode(message.code), message.reason);
+    }
+  };
+  const openLocalWebSocket = (message) => {
+    const localSocket = new WebSocket(toLocalWebSocketUrl(options.localPort, message), {
+      headers: sanitizeWebSocketHeaders(message.headers, options.localPort),
+      maxPayload: 64 * 1024 * 1024
+    });
+    localWebSockets.set(message.id, localSocket);
+    pendingLocalWebSocketMessages.set(message.id, []);
+    localSocket.on("open", () => {
+      const pendingMessages = pendingLocalWebSocketMessages.get(message.id) ?? [];
+      pendingLocalWebSocketMessages.delete(message.id);
+      for (const pendingMessage of pendingMessages) {
+        localSocket.send(pendingMessage);
+      }
+    });
+    localSocket.on("message", (data) => {
+      sendControlMessage({
+        type: "ws-message",
+        id: message.id,
+        body: encodeBody(rawDataToBuffer(data))
+      });
+    });
+    localSocket.on("close", (code, reason) => {
+      localWebSockets.delete(message.id);
+      pendingLocalWebSocketMessages.delete(message.id);
+      sendControlMessage({
+        type: "ws-close",
+        id: message.id,
+        code,
+        reason: reason.toString("utf8")
+      });
+    });
+    localSocket.on("error", () => {
+      localWebSockets.delete(message.id);
+      pendingLocalWebSocketMessages.delete(message.id);
+      sendControlMessage({
+        type: "ws-close",
+        id: message.id,
+        code: 1011,
+        reason: "Local WebSocket connection failed"
+      });
+    });
+  };
   const scheduleReconnect = () => {
     if (intentionalClose)
       return;
@@ -4333,6 +4694,7 @@ function createTunnelClient(options) {
     }
     if (message.type === "registered") {
       publicUrl = message.publicUrl;
+      registeredTunnelId = message.tunnelId;
       reconnectAttempt = 0;
       options.onRegistered?.(message);
       if (!hasRegistered) {
@@ -4368,7 +4730,7 @@ function createTunnelClient(options) {
     if (message.type === "request") {
       try {
         const response = await forwardToLocal(options.localPort, message);
-        ws?.send(JSON.stringify(response));
+        sendControlMessage(response);
       } catch (err) {
         const messageText = formatLocalProxyError(err, options.localPort);
         const errorResponse = {
@@ -4378,8 +4740,26 @@ function createTunnelClient(options) {
           headers: { "content-type": "text/plain; charset=utf-8" },
           body: Buffer.from(messageText).toString("base64")
         };
-        ws?.send(JSON.stringify(errorResponse));
+        sendControlMessage(errorResponse);
+      }
+      return;
+    }
+    if (message.type === "ws-open") {
+      openLocalWebSocket(message);
+      return;
+    }
+    if (message.type === "ws-message") {
+      const localSocket = localWebSockets.get(message.id);
+      const body = decodeBody(message.body);
+      if (localSocket?.readyState === WebSocket.OPEN) {
+        localSocket.send(body);
+      } else if (localSocket?.readyState === WebSocket.CONNECTING) {
+        pendingLocalWebSocketMessages.get(message.id)?.push(body);
       }
+      return;
+    }
+    if (message.type === "ws-close") {
+      closeLocalWebSocket(message);
     }
   };
   const openConnection = () => {
@@ -4401,7 +4781,11 @@ function createTunnelClient(options) {
         type: "register",
         localPort: options.localPort,
         token: options.token,
-        ...options.password ? { password: options.password } : {}
+        ...options.password ? { password: options.password } : {},
+        ...options.projectSlug ? { projectSlug: options.projectSlug } : {},
+        ...options.projectId ? { projectId: options.projectId } : {},
+        ...options.targetName ? { targetName: options.targetName } : {},
+        ...registeredTunnelId ? { tunnelId: registeredTunnelId } : {}
       }));
     });
     socket.on("message", (data) => {
@@ -4409,6 +4793,7 @@ function createTunnelClient(options) {
     });
     socket.on("close", () => {
       publicUrl = null;
+      closeLocalWebSockets();
       options.onDisconnect?.();
       if (!intentionalClose && !hasRegistered && connectReject) {
         connectReject(new Error("Connection closed before registration"));
@@ -4438,6 +4823,7 @@ function createTunnelClient(options) {
     disconnect() {
       intentionalClose = true;
       clearReconnect();
+      closeLocalWebSockets();
       if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
         ws.close();
       }
@@ -4460,6 +4846,9 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 var CONFIG_DIR = join(homedir(), ".shiplocal");
 var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function tunnelConfigKey(projectSlug, targetName) {
+  return `${projectSlug}:${targetName}`;
+}
 async function loadConfig() {
   try {
     const raw = await readFile(CONFIG_FILE, "utf8");
@@ -4474,12 +4863,26 @@ async function saveConfig(config) {
   await mkdir(CONFIG_DIR, { recursive: true });
   await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf8");
 }
+async function updateTunnelConfig(projectSlug, targetName, tunnelId, publicUrl) {
+  const config = await loadConfig() ?? { apiUrl: resolveApiUrl(), token: "" };
+  config.defaultProjectSlug = projectSlug;
+  config.tunnels ??= {};
+  config.tunnels[tunnelConfigKey(projectSlug, targetName)] = { tunnelId, publicUrl };
+  await saveConfig(config);
+}
+async function getSavedTunnelId(projectSlug, targetName) {
+  const config = await loadConfig();
+  return config?.tunnels?.[tunnelConfigKey(projectSlug, targetName)]?.tunnelId;
+}
 async function clearConfig() {
   try {
     await writeFile(CONFIG_FILE, "{}", "utf8");
   } catch {
   }
 }
+function resolveApiUrl() {
+  return process.env["SHIPLOCAL_API_URL"] ?? "http://localhost:4000";
+}
 var DEFAULT_CLOUD_API_URL = "https://shiplocal.cloud";
 async function resolveApiUrlAsync() {
   if (process.env["SHIPLOCAL_API_URL"]) {
@@ -4573,7 +4976,7 @@ async function isLocalPortOpen(port, timeoutMs = 2e3) {
 
 // src/index.ts
 var program = new Command();
-program.name("shiplocal").description("Share localhost with clients in seconds").version("0.1.5");
+program.name("shiplocal").description("Share localhost with clients in seconds").version("0.1.6");
 program.command("login").description("Authenticate with ShipLocal Cloud").action(async () => {
   const rl = createInterface({ input, output });
   const apiUrl = await resolveApiUrlAsync();
@@ -4604,84 +5007,131 @@ program.command("logout").description("Remove saved credentials").action(async (
   await clearConfig();
   console.log("Logged out.");
 });
-program.argument("[port]", "Local port to expose", String(DEFAULT_TUNNEL_PORT)).option("-p, --password <password>", "Require a password to open the public URL").description("Start a tunnel to your local server").action(async (portArg, options) => {
-  const port = Number.parseInt(portArg, 10);
-  if (Number.isNaN(port) || port < 1 || port > 65535) {
-    console.error("Error: port must be a number between 1 and 65535");
-    process.exit(1);
-  }
-  const serverUrl = await resolveApiUrlAsync();
-  const token = await resolveToken();
-  if (!token) {
-    console.error("Not authenticated. Run `shiplocal login` first.");
-    process.exit(1);
-  }
-  if (!token.startsWith("sl_")) {
-    console.error("Invalid saved token. Run `shiplocal login` again.");
-    process.exit(1);
-  }
-  const portOpen = await isLocalPortOpen(port);
-  if (!portOpen) {
-    console.warn("");
-    console.warn(`Warning: nothing is listening on http://localhost:${String(port)}`);
-    console.warn("Start your local app first, or pass the port it uses.");
-    console.warn("Example: pnpm tunnel 3001  (dashboard in this repo runs on 3001)");
-    console.warn("");
-  }
-  let printed = false;
-  const client = createTunnelClient({
-    serverUrl,
-    localPort: port,
-    token,
-    password: options.password,
-    onRegistered: (info) => {
-      if (!printed) {
-        console.log("");
-        console.log("\u{1F680} ShipLocal running");
-        console.log("");
-        console.log(`Local:   http://localhost:${String(port)}`);
-        console.log(`Public:  ${info.publicUrl}`);
-        if (options.password) {
-          console.log(`Password: ${options.password} (share with your client)`);
+program.argument("[port]", "Local port to expose", String(DEFAULT_TUNNEL_PORT)).option("-p, --password <password>", "Require a password to open the public URL").option("--project <slug>", "Project slug for coordinated multi-target URLs").option("--name <target>", "Target name within project (default: web)", "web").option("--rewrite-env", "Suggest or apply .env URL rewrites for tunnel URLs").description("Start a tunnel to your local server").action(
+  async (portArg, options) => {
+    const port = Number.parseInt(portArg, 10);
+    if (Number.isNaN(port) || port < 1 || port > 65535) {
+      console.error("Error: port must be a number between 1 and 65535");
+      process.exit(1);
+    }
+    const serverUrl = await resolveApiUrlAsync();
+    const token = await resolveToken();
+    if (!token) {
+      console.error("Not authenticated. Run `shiplocal login` first.");
+      process.exit(1);
+    }
+    if (!token.startsWith("sl_")) {
+      console.error("Invalid saved token. Run `shiplocal login` again.");
+      process.exit(1);
+    }
+    const projectSlug = options.project?.toLowerCase();
+    const targetName = normalizeTargetName(options.name);
+    const savedTunnelId = projectSlug !== void 0 ? await getSavedTunnelId(projectSlug, targetName) : void 0;
+    const portOpen = await isLocalPortOpen(port);
+    if (!portOpen) {
+      console.warn("");
+      console.warn(`Warning: nothing is listening on http://localhost:${String(port)}`);
+      console.warn("Start your local app first, or pass the port it uses.");
+      console.warn("Example: pnpm tunnel 3001  (dashboard in this repo runs on 3001)");
+      console.warn("");
+    }
+    let printed = false;
+    const client = createTunnelClient({
+      serverUrl,
+      localPort: port,
+      token,
+      password: options.password,
+      projectSlug,
+      targetName: projectSlug ? targetName : void 0,
+      tunnelId: savedTunnelId,
+      onRegistered: (info) => {
+        if (info.projectSlug && info.targetName) {
+          void updateTunnelConfig(
+            info.projectSlug,
+            info.targetName,
+            info.tunnelId,
+            info.publicUrl
+          );
         }
+        if (!printed) {
+          console.log("");
+          console.log("\u{1F680} ShipLocal running");
+          console.log("");
+          console.log(`Local:   http://localhost:${String(port)}`);
+          console.log(`Public:  ${info.publicUrl}`);
+          if (info.projectSlug) {
+            console.log(`Project: ${info.projectSlug} (${info.targetName ?? targetName})`);
+          }
+          if (info.siblingUrls && info.siblingUrls.length > 0) {
+            console.log("");
+            console.log("Other targets in this project:");
+            for (const sibling of info.siblingUrls) {
+              console.log(
+                `  ${sibling.name}: ${sibling.publicUrl} (port ${String(sibling.port)})`
+              );
+            }
+          }
+          if (options.password) {
+            console.log(`Password: ${options.password} (share with your client)`);
+          }
+          console.log("");
+          console.log("Share this with your client.");
+          console.log("Press Ctrl+C to stop.");
+          printed = true;
+          if (options.rewriteEnv) {
+            void Promise.resolve().then(() => (init_env_rewrite(), env_rewrite_exports)).then(
+              ({ runEnvRewrite: runEnvRewrite2 }) => runEnvRewrite2({
+                port,
+                publicUrl: info.publicUrl,
+                siblingUrls: info.siblingUrls ?? [],
+                write: true
+              })
+            );
+          } else if (projectSlug) {
+            void Promise.resolve().then(() => (init_env_rewrite(), env_rewrite_exports)).then(
+              ({ runEnvRewrite: runEnvRewrite2 }) => runEnvRewrite2({
+                port,
+                publicUrl: info.publicUrl,
+                siblingUrls: info.siblingUrls ?? [],
+                write: false
+              })
+            );
+          }
+        } else {
+          console.log(`Reconnected: ${info.publicUrl}`);
+        }
+      },
+      onReconnecting: (attempt) => {
+        console.log(`Reconnecting\u2026 (attempt ${String(attempt)})`);
+      },
+      onTerminated: (message) => {
+        console.log("");
+        console.log(message);
+        console.log("Run shiplocal again to start a new tunnel.");
         console.log("");
-        console.log("Share this with your client.");
-        console.log("Press Ctrl+C to stop.");
-        printed = true;
-      } else {
-        console.log(`Reconnected: ${info.publicUrl}`);
       }
-    },
-    onReconnecting: (attempt) => {
-      console.log(`Reconnecting\u2026 (attempt ${String(attempt)})`);
-    },
-    onTerminated: (message) => {
-      console.log("");
-      console.log(message);
-      console.log("Run shiplocal again to start a new tunnel.");
-      console.log("");
-    }
-  });
-  const shutdown = () => {
-    void client.disconnect().then(() => {
-      process.exit(0);
     });
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  try {
-    await client.connect();
-  } catch (err) {
-    const apiUrl = await resolveApiUrlAsync();
-    const message = err instanceof Error && err.message.includes("ECONNREFUSED") ? [
-      `Cannot reach ShipLocal server at ${apiUrl}.`,
-      "",
-      "Start the API server first:",
-      "  pnpm dev"
-    ].join("\n") : err instanceof Error ? err.message : String(err);
-    console.error(message);
-    process.exit(1);
+    const shutdown = () => {
+      void client.disconnect().then(() => {
+        process.exit(0);
+      });
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    try {
+      await client.connect();
+    } catch (err) {
+      const apiUrl = await resolveApiUrlAsync();
+      const message = err instanceof Error && err.message.includes("ECONNREFUSED") ? [
+        `Cannot reach ShipLocal server at ${apiUrl}.`,
+        "",
+        "Start the API server first:",
+        "  pnpm dev"
+      ].join("\n") : err instanceof Error ? err.message : String(err);
+      console.error(message);
+      process.exit(1);
+    }
   }
-});
+);
 program.parse();
 //# sourceMappingURL=index.js.map