@akanjs/devkit 1.0.20 → 2.1.0-rc.1

package/{esm/src/capacitorApp.js → src/capacitorApp.ts}

@@ -1,25 +1,39 @@
-import { capitalize } from "@akanjs/common";
+import type { CapacitorConfig } from "@capacitor/cli";
 import { MobileProject } from "@trapezedev/project";
-import fs from "fs";
+import type { AndroidProject } from "@trapezedev/project/dist/android/project";
+import type { IosProject } from "@trapezedev/project/dist/ios/project";
+import { capitalize } from "akanjs/common";
+import { type AppExecutor, FileSys } from "@akanjs/devkit";
+
 import { FileEditor } from "./fileEditor";
-class CapacitorApp {
-  constructor(app) {
-    this.app = app;
+
+interface RunConfig extends CapacitorConfig {
+  operation: "local" | "release";
+  version: string;
+  buildNum: number;
+  appId?: string;
+  host?: "local" | "debug" | "develop" | "main";
+}
+
+export class CapacitorApp {
+  project: MobileProject & { ios: IosProject; android: AndroidProject };
+  iosTargetName = "App";
+  constructor(private readonly app: AppExecutor) {
     this.project = new MobileProject(this.app.cwdPath, {
       android: { path: "android" },
-      ios: { path: "ios/App" }
-    });
+      ios: { path: "ios/App" },
+    }) as MobileProject & { ios: IosProject; android: AndroidProject };
   }
-  project;
-  iosTargetName = "App";
   async init() {
-    const project = this.project;
+    const project = this.project as MobileProject;
     await this.project.load();
-    if (!project.android) {
+    const hasAndroid = await FileSys.fileExists(`${this.app.cwdPath}/android/app/build.gradle`);
+    const hasIos = await FileSys.fileExists(`${this.app.cwdPath}/ios/App/App.xcodeproj/project.pbxproj`);
+    if (!project.android && !hasAndroid) {
       await this.app.spawn("npx", ["cap", "add", "android"]);
       await this.project.load();
     }
-    if (!project.ios) {
+    if (!project.ios && !hasIos) {
       await this.app.spawn("npx", ["cap", "add", "ios"]);
       await this.project.load();
     }
@@ -29,12 +43,11 @@ class CapacitorApp {
     await this.project.commit();
   }
   async #prepareIos() {
-    const isAdded = fs.existsSync(`${this.app.cwdPath}/ios/App/Podfile`);
+    const isAdded = await FileSys.fileExists(`${this.app.cwdPath}/ios/App/App.xcodeproj/project.pbxproj`);
     if (!isAdded) {
       await this.app.spawn("npx", ["cap", "add", "ios"]);
       await this.app.spawn("npx", ["@capacitor/assets", "generate"]);
-    } else
-      this.app.verbose(`iOS already added, skip adding process`);
+    } else this.app.verbose(`iOS already added, skip adding process`);
     this.app.verbose(`syncing iOS`);
     await this.app.spawn("npx", ["cap", "sync", "ios"]);
     this.app.verbose(`sync completed.`);
@@ -50,7 +63,7 @@ class CapacitorApp {
   async openIos() {
     await this.app.spawn("npx", ["cap", "open", "ios"]);
   }
-  async runIos({ operation, appId, version = "0.0.1", buildNum = 1, host = "local" }) {
+  async runIos({ operation, appId, version = "0.0.1", buildNum = 1, host = "local" }: RunConfig) {
     const defaultAppId = `com.${this.app.name}.app`;
     await this.#prepareIos();
     this.project.ios.setBundleId("App", "Debug", appId ?? defaultAppId);
@@ -62,35 +75,29 @@ class CapacitorApp {
     await this.project.commit();
     await this.app.spawn(
       "npx",
-      [
-        "cross-env",
-        `APP_OPERATION_MODE=${operation}`,
-        `NEXT_PUBLIC_ENV=${host}`,
-        "npx",
-        "cap",
-        "run",
-        "ios",
-        "--live-reload",
-        operation === "release" ? "" : "--live-reload",
-        operation === "release" ? "" : "--port",
-        operation === "release" ? "" : "4201"
-      ],
+      ["cross-env", `APP_OPERATION_MODE=${operation}`, `BUN_PUBLIC_ENV=${host}`, "npx", "cap", "run", "ios"],
       {
-        stdio: "inherit"
-      }
+        stdio: "inherit",
+      },
     );
+
+    // this.project.ios.incrementBuild("App", "Debug");
+    // this.project.ios.incrementBuild("App", "Release");
   }
+
   async #prepareAndroid() {
-    const isAdded = fs.existsSync(`${this.app.cwdPath}/android/app/build.gradle`);
+    const isAdded = await Bun.file(`${this.app.cwdPath}/android/app/build.gradle`).exists();
     if (!isAdded) {
       await this.app.spawn("npx", ["cap", "add", "android"]);
-    } else
-      this.app.verbose(`Android already added, skip adding process`);
+    } else this.app.verbose(`Android already added, skip adding process`);
     await this.app.spawn("npx", ["@capacitor/assets", "generate"]);
     await this.app.spawn("npx", ["cap", "sync", "android"]);
   }
-  #updateAndroidBuildTypes() {
-    const appGradle = new FileEditor(`${this.app.cwdPath}/android/app/build.gradle`);
+
+  async #updateAndroidBuildTypes() {
+    //keystore 기본 설정 및 debug, release 설정
+
+    const appGradle = await FileEditor.create(`${this.app.cwdPath}/android/app/build.gradle`);
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -123,16 +130,18 @@ class CapacitorApp {
     if (appGradle.find(`applicationIdSuffix ".debug"`) === -1) {
       appGradle.insertAfter("buildTypes {", buildTypesBlock);
     }
-    appGradle.save();
+    await appGradle.save();
   }
-  async buildAndroid(assembleType) {
+  async buildAndroid(assembleType: "apk" | "aab") {
     await this.#prepareAndroid();
-    this.#updateAndroidBuildTypes();
+    await this.#updateAndroidBuildTypes();
+    //윈도우는 gradlew.bat 사용
     const isWindows = process.platform === "win32";
     const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
+
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: `${this.app.cwdPath}/android`
+      cwd: `${this.app.cwdPath}/android`,
     });
   }
   async openAndroid() {
@@ -142,7 +151,7 @@ class CapacitorApp {
     await this.#prepareAndroid();
     this.app.log(`Sync Android Completed.`);
   }
-  async runAndroid({ operation, appName, appId, version = "0.0.1", buildNum = 1, host = "local" }) {
+  async runAndroid({ operation, appName, appId, version = "0.0.1", buildNum = 1, host = "local" }: RunConfig) {
     const defaultAppId = `com.${this.app.name}.app`;
     const defaultAppName = this.app.name;
     await this.project.android.setVersionName(version);
@@ -153,28 +162,20 @@ class CapacitorApp {
     await this.project.android.setAppName(appName ?? defaultAppName);
     await this.project.commit();
     await this.#prepareAndroid();
+
     this.app.logger.info(`Running Android in ${operation} mode on ${host} host`);
     await this.app.spawn(
       "npx",
-      [
-        "cross-env",
-        `NEXT_PUBLIC_ENV=${host}`,
-        `APP_OPERATION_MODE=${operation}`,
-        "npx",
-        "cap",
-        "run",
-        "android",
-        operation === "release" ? "" : "--live-reload",
-        operation === "release" ? "" : "--port",
-        operation === "release" ? "" : "4201"
-      ],
+      ["cross-env", `BUN_PUBLIC_ENV=${host}`, `APP_OPERATION_MODE=${operation}`, "npx", "cap", "run", "android"],
       {
-        stdio: "inherit"
-      }
+        stdio: "inherit",
+      },
     );
   }
+
   //? 릴리즈시 buildNum +1 version 파라미터 받아서 업데이트
-  async updateAndroidVersion(version, buildNum) {
+  async updateAndroidVersion(version: string, buildNum: number) {
+    //TODO: 테스트 확인 필요
     await this.project.android.setVersionName(version);
     await this.project.android.setVersionCode(buildNum);
     const versionName = await this.project.android.getVersionName();
@@ -182,99 +183,99 @@ class CapacitorApp {
     await this.project.commit();
   }
   async releaseIos() {
-    const isAdded = fs.existsSync(`${this.app.cwdPath}/ios/App/Podfile`);
+    //TODO: 작업 필요
+    const isAdded = await Bun.file(`${this.app.cwdPath}/ios/App/App.xcodeproj/project.pbxproj`).exists();
     if (!isAdded) {
       await this.app.spawn("npx cap add ios");
       await this.app.spawn("npx @capacitor/assets generate");
-    } else
-      this.app.log(`iOS already added, skip adding process`);
+    } else this.app.log(`iOS already added, skip adding process`);
     await this.app.spawn("cross-env", ["APP_OPERATION_MODE=release", "npx", "cap", "sync", "ios"]);
   }
   async releaseAndroid() {
-    const isAdded = fs.existsSync(`${this.app.cwdPath}/android/app/build.gradle`);
+    //TODO: 작업 필요
+    const isAdded = await Bun.file(`${this.app.cwdPath}/android/app/build.gradle`).exists();
     if (!isAdded) {
       await this.app.spawn("npx cap add android");
       await this.app.spawn("npx @capacitor/assets generate");
-    } else
-      this.app.log(`android already added, skip adding process`);
+    } else this.app.log(`android already added, skip adding process`);
     await this.app.spawn("cross-env", ["APP_OPERATION_MODE=release", "npx", "cap", "sync", "android"]);
   }
   async addCamera() {
     await this.#setPermissionInIos({
       cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
       photoAddUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
-      photoUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos."
+      photoUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
     });
     this.#setPermissionsInAndroid(["READ_MEDIA_IMAGES", "READ_EXTERNAL_STORAGE", "WRITE_EXTERNAL_STORAGE"]);
   }
   async addContact() {
     await this.#setPermissionInIos({
-      contactsUsageDescription: "$(PRODUCT_NAME) requires access to the contacts to add new contacts."
+      contactsUsageDescription: "$(PRODUCT_NAME) requires access to the contacts to add new contacts.",
     });
     this.#setPermissionsInAndroid(["READ_CONTACTS", "WRITE_CONTACTS"]);
   }
   async addLocation() {
     await this.#setPermissionInIos({
       locationAlwaysUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
-      locationWhenInUseUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location."
+      locationWhenInUseUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
     });
     this.#setPermissionsInAndroid(["ACCESS_COARSE_LOCATION", "ACCESS_FINE_LOCATION"]);
     this.#setFeaturesInAndroid(["android.hardware.location.gps"]);
   }
-  async #setPermissionInIos(permissions) {
+  async #setPermissionInIos(permissions: { [key: string]: string }) {
     const updateNs = Object.fromEntries(
-      Object.entries(permissions).map(([key, value]) => [`NS${capitalize(key)}`, value])
+      Object.entries(permissions).map(([key, value]) => [`NS${capitalize(key)}`, value]),
     );
     await Promise.all([
       this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
-      this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs)
+      this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs),
     ]);
   }
-  #setFeaturesInAndroid(features) {
+  #setFeaturesInAndroid(features: string[]) {
     for (const feature of features) {
       if (this.#hasFeatureInAndroid(feature)) {
         this.app.logger.info(`${feature} already exists in android`);
         return this;
       }
       this.app.logger.info(`Adding ${feature} to android`);
-      this.project.android.getAndroidManifest().injectFragment("manifest", `<uses-feature android:name="${feature}" />`);
+      this.project.android
+        .getAndroidManifest()
+        .injectFragment("manifest", `<uses-feature android:name="${feature}" />`);
     }
     return this;
   }
   #getFeaturesInAndroid() {
     const androidManifest = this.project.android.getAndroidManifest();
     const element = androidManifest.getDocumentElement();
-    if (!element)
-      throw new Error("manifest not found");
+    if (!element) throw new Error("manifest not found");
     const usesFeature = element.getElementsByTagName("uses-feature");
     return Array.from(usesFeature).map((feature) => feature.getAttribute("android:name"));
   }
-  #hasFeatureInAndroid(feature) {
+  #hasFeatureInAndroid(feature: string) {
     return this.#getFeaturesInAndroid().includes(feature);
   }
-  #setPermissionsInAndroid(permissions) {
+
+  #setPermissionsInAndroid(permissions: string[]) {
     for (const permission of permissions) {
       if (this.#hasPermissionInAndroid(permission)) {
         this.app.logger.info(`${permission} already exists in android`);
         return this;
       }
       this.app.logger.info(`Adding ${permission} to android`);
-      this.project.android.getAndroidManifest().injectFragment("manifest", `<uses-permission android:name="android.permission.${permission}" />`);
+      this.project.android
+        .getAndroidManifest()
+        .injectFragment("manifest", `<uses-permission android:name="android.permission.${permission}" />`);
     }
     return this;
   }
   #getPermissionsInAndroid() {
     const androidManifest = this.project.android.getAndroidManifest();
     const element = androidManifest.getDocumentElement();
-    if (!element)
-      throw new Error("manifest not found");
+    if (!element) throw new Error("manifest not found");
     const usesPermission = element.getElementsByTagName("uses-permission");
     return Array.from(usesPermission).map((permission) => permission.getAttribute("android:name"));
   }
-  #hasPermissionInAndroid(permission) {
+  #hasPermissionInAndroid(permission: string) {
     return this.#getPermissionsInAndroid().includes(permission);
   }
 }
-export {
-  CapacitorApp
-};

package/sshTunnel.ts

@@ -0,0 +1,152 @@
+import { type Channel, Client, type ConnectConfig } from "ssh2";
+
+export interface SshTunnelOptions {
+  localHost?: string;
+  localPort: number;
+  srcHost?: string;
+  srcPort?: number;
+  dstHost: string;
+  dstPort: number;
+  sshOptions: ConnectConfig;
+}
+
+export interface SshTunnel {
+  close(): void;
+}
+
+interface TunnelSocketData {
+  stream?: Channel;
+  pending: Buffer[];
+  closed: boolean;
+}
+
+type BunServer = { stop(): void };
+type BunSocket = Bun.Socket<TunnelSocketData>;
+
+const closeQuietly = (close: () => void) => {
+  try {
+    close();
+  } catch {
+    // The opposite side may already have closed the tunnel.
+  }
+};
+
+const createSshClient = async (options: SshTunnelOptions) =>
+  new Promise<Client>((resolve, reject) => {
+    const client = new Client();
+
+    const cleanup = () => {
+      client.off("ready", onReady);
+      client.off("error", onError);
+      client.off("close", onClose);
+    };
+
+    const onReady = () => {
+      cleanup();
+      resolve(client);
+    };
+
+    const onError = (error: Error) => {
+      cleanup();
+      reject(error);
+    };
+
+    const onClose = () => {
+      cleanup();
+      reject(new Error("SSH tunnel closed before it was ready"));
+    };
+
+    client.once("ready", onReady);
+    client.once("error", onError);
+    client.once("close", onClose);
+    client.connect({ readyTimeout: 10000, ...options.sshOptions });
+  });
+
+export const createSshTunnel = async (options: SshTunnelOptions): Promise<SshTunnel> => {
+  const client = await createSshClient(options);
+  const sockets = new Set<BunSocket>();
+  let closing = false;
+
+  const closeSocket = (socket: BunSocket, error?: Error) => {
+    sockets.delete(socket);
+    closeBunSocket(socket, error);
+  };
+
+  try {
+    const server = Bun.listen<TunnelSocketData>({
+      hostname: options.localHost ?? "127.0.0.1",
+      port: options.localPort,
+      socket: {
+        open(socket) {
+          sockets.add(socket);
+          socket.data = { pending: [], closed: false };
+
+          client.forwardOut(
+            options.srcHost ?? "127.0.0.1",
+            options.srcPort ?? options.localPort,
+            options.dstHost,
+            options.dstPort,
+            (error, stream) => {
+              if (error) {
+                closeSocket(socket, error);
+                return;
+              }
+
+              if (socket.data.closed) {
+                stream.destroy();
+                return;
+              }
+
+              socket.data.stream = stream;
+              stream.on("data", (chunk: Buffer) => socket.write(chunk));
+              stream.once("close", () => closeSocket(socket));
+              stream.once("error", (streamError: Error) => closeSocket(socket, streamError));
+
+              for (const chunk of socket.data.pending) stream.write(chunk);
+              socket.data.pending = [];
+            },
+          );
+        },
+        data(socket, chunk) {
+          const buffer = Buffer.from(chunk);
+          if (socket.data.stream) socket.data.stream.write(buffer);
+          else socket.data.pending.push(buffer);
+        },
+        close(socket) {
+          closeSocket(socket);
+        },
+        error(socket, error) {
+          closeSocket(socket, error);
+        },
+      },
+    });
+
+    const closeTunnel = (error?: Error) => {
+      if (closing) return;
+      closing = true;
+      for (const socket of sockets) closeSocket(socket, error);
+      closeQuietly(() => client.end());
+      closeBunServer(server);
+    };
+
+    client.once("error", (error) => closeTunnel(error));
+    client.once("close", () => closeTunnel());
+
+    return { close: closeTunnel };
+  } catch (error) {
+    closeQuietly(() => client.end());
+    throw error;
+  }
+};
+
+const closeBunSocket = (socket: BunSocket, error?: Error) => {
+  if (socket.data.closed) return;
+  socket.data.closed = true;
+  if (error) socket.data.stream?.destroy();
+  else socket.data.stream?.end();
+  closeQuietly(() => socket.end());
+};
+
+const closeBunServer = (server: BunServer) => {
+  server.stop();
+};

package/{esm/src/streamAi.js → streamAi.ts}

@@ -1,18 +1,25 @@
 import { PromptTemplate } from "@langchain/core/prompts";
 import { RunnableSequence } from "@langchain/core/runnables";
 import { ChatOpenAI } from "@langchain/openai";
-const streamAi = async (question, callback = (chunk) => {
-  process.stdout.write(chunk);
-}) => {
+
+interface StreamResponse {
+  content: string;
+  chunk?: string;
+}
+
+export const streamAi = async (
+  question: string,
+  callback: (chunk: string) => void = (chunk) => {
+    process.stdout.write(chunk);
+  },
+): Promise<StreamResponse> => {
   const createStreamingModel = (apiKey = process.env.DEEPSEEK_API_KEY) => {
-    if (!apiKey)
-      throw new Error(`process.env.DEEPSEEK_API_KEY is not set`);
+    if (!apiKey) throw new Error(`process.env.DEEPSEEK_API_KEY is not set`);
     return new ChatOpenAI({
       modelName: "deepseek-reasoner",
       temperature: 0.7,
-      streaming: true,
-      // Enable streaming
-      configuration: { baseURL: "https://api.deepseek.com/v1", apiKey }
+      streaming: true, // Enable streaming
+      configuration: { baseURL: "https://api.deepseek.com/v1", apiKey },
     });
   };
   const createProcessingChain = () => {
@@ -21,19 +28,18 @@ const streamAi = async (question, callback = (chunk) => {
   try {
     const chain = createProcessingChain();
     const stream = await chain.stream({ question });
+
     let fullResponse = "";
     for await (const chunk of stream) {
       const content = chunk.content;
       if (typeof content === "string") {
         fullResponse += content;
-        callback(content);
+        callback(content); // Send individual chunks to callback
       }
     }
+
     return { content: fullResponse };
   } catch (error) {
     throw new Error("Failed to stream response");
   }
 };
-export {
-  streamAi
-};