Codeinterpreter start command (#79)

* Add details about sandbox continuous runtime limits

* Update port-not-open troubleshooting page

* Update from-image to from-template in example

* fixing typo

* fixing more typos

* fix typo

* persistance fixes

* changed js to ts in example

* remove note

Author: beran-t

docs/sandbox.mdx

@@ -5,6 +5,15 @@ sidebarTitle: Lifecycle
 
 When you start the sandbox, it stays alive for 5 minutes by default but you can change it by passing the `timeout` parameter.
 After the time passes, the sandbox will be automatically shutdown.
+
+<Warning>
+The maximum time sandbox can be kept running without being paused is 
+- 24 hours on the Pro Tier
+- 1 hour on the Base Tier
+
+For more details, please refer to [sandbox persistance page](/docs/sandbox/persistence#limitations-while-in-beta).
+</Warning>
+
 <CodeGroup>
 ```js JavaScript & TypeScript highlight={6}
 import { Sandbox } from '@e2b/code-interpreter'
@@ -29,12 +38,12 @@ sandbox = Sandbox.create(
 
 ## Change sandbox timeout during runtime
 
-You can change the sandbox timeout when it's running by calling the the `setTimeout` method in JavaScript or `set_timeout` method in Python.
+You can change the sandbox timeout when it's running by calling the `setTimeout` method in JavaScript or `set_timeout` method in Python.
 
 When you call the set timeout method, the sandbox timeout will be reset to the new value that you specified.
 
 This can be useful if you want to extend the sandbox lifetime when it's already running.
-You can for example start with a sandbox with 1 minute timeout and then periodically call set timout every time user interacts with it in your app.
+You can for example start with a sandbox with 1 minute timeout and then periodically call set timeout every time user interacts with it in your app.
 
 <CodeGroup>
 ```js JavaScript & TypeScript

docs/sandbox/connect-bucket.mdx

@@ -24,7 +24,7 @@ To use the Google Cloud Storage we need to install the `gcsfuse` package. There'
 
 ```ts JavaScript & TypeScript
 const template = Template()
-  .fromImage("e2bdev/code-interpreter:latest")
+  .fromTemplate("code-interpreter-v1")
   .aptInstall(["gnupg", "lsb-release"])
   .runCmd("lsb_release -c -s > /tmp/lsb_release")
   .runCmd(
@@ -34,14 +34,13 @@ const template = Template()
     "curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo tee /usr/share/keyrings/cloud.google.asc",
   )
   .aptInstall(["gcsfuse"])
-  .setStartCmd("sudo /root/.jupyter/start-up.sh", waitForPort(49999));
 ```
 
 
 ```python Python
 template = (
     Template()
-    .from_image("e2bdev/code-interpreter:latest")
+    .from_template("code-interpreter-v1")
     .apt_install(["gnupg", "lsb-release"])
     .run_cmd("lsb_release -c -s > /tmp/lsb_release")
     .run_cmd(
@@ -51,7 +50,6 @@ template = (
         "curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo tee /usr/share/keyrings/cloud.google.asc"
     )
     .apt_install(["gcsfuse"])
-    .set_start_cmd("sudo /root/.jupyter/start-up.sh", wait_for_port(49999))
 )
 ```
 

docs/sandbox/persistence.mdx

@@ -275,7 +275,21 @@ If you resume the sandbox, the service will be accessible again but you need to
 
 
 ## Limitations while in beta
-- Pausing a sandbox takes about 4 seconds per 1 GiB of RAM
-- Resuming a sandbox takes about 1 second
-- Sandbox can be used up to 30 days
-  - After 30 days from the initial sandbox create call, the data may be deleted and you will not be able to resume it. Attempting to resume a sandbox that was deleted or does not exist will result in the `NotFoundError` in the JavaScript SDK or the `NotFoundException` in the Python SDK
+
+### Lifecycle duration
+- A sandbox can exist for **up to 30 days** from the initial `create` call.
+- After 30 days, sandbox data **may be deleted** and the sandbox can no longer be resumed.
+- Attempting to resume a deleted or non-existent sandbox will result in:
+  - `NotFoundError` in the JavaScript SDK
+  - `NotFoundException` in the Python SDK
+
+### Pause and resume performance
+- Pausing a sandbox takes approximately **4 seconds per 1 GiB of RAM**
+- Resuming a sandbox takes approximately **1 second**
+
+### Continuous runtime limits
+- A sandbox can remain running (without being paused) for:
+  - **24 hours** on the **Pro tier**
+  - **1 hour** on the **Base tier**
+- After a sandbox is paused and resumed, the continuous runtime limit is **reset**
+- The **30-day total lifetime limit** still applies regardless of how many times the sandbox is paused or resumed

docs/troubleshooting/templates/49999-port-not-open.mdx

@@ -19,10 +19,6 @@ The reason for this is that either the default start command is not specified on
 
 With the current build system, you need to use the `code-interpreter` as a base template in your template definition.
 
-<Note>
-    The default start command for the `code-interpreter` template is `/root/.jupyter/start-up.sh`.
-</Note>
-
 <CodeGroup>
 ```js JavaScript & TypeScript
 import { Template } from '@e2b/code-interpreter'
@@ -36,6 +32,33 @@ template = Template().from_template("code-interpreter-v1")
 ```
 </CodeGroup>
 
+<Note>
+We strongly recommend building custom template via the previous example. However, if you choose to build from docker image, do as follows.
+</Note>
+
+<CodeGroup>
+```ts JavaScript & TypeScript
+import { Template, waitForURL } from '@e2b/code-interpreter'
+
+const template = Template()
+    .fromImage("e2bdev/code-interpreter:latest")
+    .setStartCmd(
+        "sudo /root/.jupyter/start-up.sh", waitForURL("http://localhost:49999/health")
+    )
+```
+```python Python
+from e2b_code_interpreter import Template, wait_for_url
+
+template = (
+    Template()
+    .from_image("e2bdev/code-interpreter:latest")
+    .set_start_cmd(
+        "sudo /root/.jupyter/start-up.sh", wait_for_url("http://localhost:49999/health")
+    )
+)
+```
+</CodeGroup>
+
 ### Legacy Build System
 
 If you are using the legacy build system, you need to use Code Interpreter image as a base image: